v2.3.1

CameraDevice: Release surface when closing camera device.

.travis.yml

@@ -5,9 +5,13 @@ android:
   components:
   - tools
   - platform-tools
-  - build-tools-25.0.2
-  - android-25
+  - tools
+  - build-tools-27.0.3
+  - android-27
   - extra-android-m2repository
 
+before_install:
+- yes | sdkmanager "platforms;android-27"
+
 script:
   - ./gradlew build test

README.md

@@ -1,33 +1,34 @@
 # Fotoapparat
 
-![Build status](https://travis-ci.org/Fotoapparat/Fotoapparat.svg?branch=master)
+![Build status](https://travis-ci.org/RedApparat/Fotoapparat.svg?branch=master)
 
 
 ![ ](sample/src/main/res/mipmap-xxxhdpi/ic_launcher.png)
 
-Camera API in Android is hard. Having 2 different API for new and old Camera does not make things any easier. But fret not, that is your lucky day! After several years of working with Camera we came up with Fotoapparat.
+Camera API in Android is hard. Having 2 different API for new and old Camera does not make things any easier. But fret not, that is your lucky day! After several years of working with Camera, we came up with Fotoapparat.
 
 What it provides:
 - Camera API which does not allow you to shoot yourself in the foot.
 - Simple yet powerful parameters customization.
 - Standalone custom `CameraView` which can be integrated into any `Activity`.
 - Fixes and workarounds for device-specific problems.
+- Both Kotlin and Java friendly configurations.
 - Last, but not least, non 0% test coverage. 
 
 
 Taking picture becomes as simple as:
 
-```java
-Fotoapparat fotoapparat = Fotoapparat
-    .with(context)  
-    .into(cameraView)
-    .build();
-
-fotoapparat.start();
+```kotlin
+val fotoapparat = Fotoapparat(
+    context = this,
+    view = cameraView
+)
+ 
+fotoapparat.start()
     
 fotoapparat
     .takePicture()
-    .saveToFile(someFile);
+    .saveToFile(someFile)
 ```
 
 ## How it works
@@ -45,109 +46,115 @@ Add `CameraView` to your layout
 
 ### Step Two
 
-Configure `Fotoapparat` instance
+Configure `Fotoapparat` instance.
+
+```kotlin 
+Fotoapparat(
+            context = this,
+            view = cameraView,                   // view which will draw the camera preview
+            scaleType = ScaleType.CenterCrop,    // (optional) we want the preview to fill the view
+            lensPosition = back(),               // (optional) we want back camera
+            cameraConfiguration = configuration, // (optional) define an advanced configuration
+            logger = loggers(                    // (optional) we want to log camera events in 2 places at once
+                     logcat(),                   // ... in logcat
+                     fileLogger(this)            // ... and to file
+            ),
+            cameraErrorCallback = { error -> }   // (optional) log fatal errors
+    )
+``` 
+Check the [wiki for the `configuration` options e.g. change iso](https://github.com/Fotoapparat/Fotoapparat/wiki/Configuration-Kotlin)
+
+Are you using Java only? See our [wiki for the java-friendly configuration](https://github.com/Fotoapparat/Fotoapparat/wiki/Configuration-Java).
 
-```java
-Fotoapparat
-    .with(context)  
-    .into(cameraView)           // view which will draw the camera preview
-    .previewScaleType(ScaleType.CENTER_CROP)  // we want the preview to fill the view  
-    .photoSize(biggestSize())   // we want to have the biggest photo possible
-    .lensPosition(back())       // we want back camera
-    .focusMode(firstAvailable(  // (optional) use the first focus mode which is supported by device
-            continuousFocus(),
-            autoFocus(),        // in case if continuous focus is not available on device, auto focus will be used
-            fixed()             // if even auto focus is not available - fixed focus mode will be used
-    ))
-    .flash(firstAvailable(      // (optional) similar to how it is done for focus mode, this time for flash
-            autoRedEye(),
-            autoFlash(),
-            torch()
-    ))
-    .frameProcessor(myFrameProcessor)   // (optional) receives each frame from preview stream
-    .logger(loggers(            // (optional) we want to log camera events in 2 places at once
-            logcat(),           // ... in logcat
-            fileLogger(this)    // ... and to file
-    ))
-    .build();
-```
 
 ### Step Three
 
 Call `start()` and `stop()`. No rocket science here.
 
-```java
-@Override
-protected void onStart() {
-    super.onStart();
-    fotoapparat.start();
+```kotlin
+override fun onStart() {
+    super.onStart()
+    fotoapparat.start()
 }
-
-@Override
-protected void onStop() {
-    super.onStop();
-    fotoapparat.stop();
+ 
+override fun onStop() {
+    super.onStop()
+    fotoapparat.stop()
 }
 ```
 
-### Take picture
+### Take a picture
 
-Finally we are ready to take picture. You have various options.
+Finally, we are ready to take a picture. You have various options.
 
-```java
-PhotoResult photoResult = fotoapparat.takePicture();
+```kotlin
+val photoResult = fotoapparat.takePicture()
  
 // Asynchronously saves photo to file
-photoResult.saveToFile(someFile);
+photoResult.saveToFile(someFile)
  
-// Asynchronously converts photo to bitmap and returns result on main thread
+// Asynchronously converts photo to bitmap and returns the result on the main thread
 photoResult
     .toBitmap()
-    .whenAvailable(new PendingResult.Callback<BitmapPhoto>() {
-        @Override
-        public void onResult(BitmapPhoto result) {
-            ImageView imageView = (ImageView) findViewById(R.id.result);
-
-            imageView.setImageBitmap(result.bitmap);
-            imageView.setRotation(-result.rotationDegrees);
-        }
-    });
-    
-// Of course you can also get a photo in a blocking way. Do not do it on main thread though.
-BitmapPhoto result = photoResult.toBitmap().await();
+    .whenAvailable { bitmapPhoto ->
+            val imageView = (ImageView) findViewById(R.id.result)
  
-// Convert asynchronous events to RxJava 1.x/2.x types. See /fotoapparat-adapters/ module
+            imageView.setImageBitmap(bitmapPhoto.bitmap)
+            imageView.setRotation(-bitmapPhoto.rotationDegrees)
+    }
+    
+// Of course, you can also get a photo in a blocking way. Do not do it on the main thread though.
+val result = photoResult.toBitmap().await()
+ 
+// Convert asynchronous events to RxJava 1.x/2.x types. 
+// See /fotoapparat-adapters/ module 
 photoResult
         .toBitmap()
-        .adapt(SingleAdapter.<BitmapPhoto>toSingle())
-        .subscribe(bitmapPhoto -> {
+        .toSingle()
+        .subscribe { bitmapPhoto -> 
             
-        });
+        }
 ```
 
 ## Update parameters
 
 It is also possible to update some parameters after `Fotoapparat` was already started.
 
-```java
-fotoapparat.updateParameters(
-        UpdateRequest.builder()
-                .flash(
-                    isTurnedOn 
-                        ? torch() 
-                        : off()
-                )
-                .build()
+```kotlin
+fotoapparat.updateConfiguration(
+        UpdateConfiguration(
+                flashMode = if (isChecked) torch() else off()
+                // ...
+                // all the parameters available in CameraConfiguration 
+        )
+)
+```
+
+Or alternatively, you may provide updates on an existing full configuration. 
+
+```kotlin
+val configuration = CameraConfiguration(
+    // A full configuration
+    // ...
+)
+ 
+fotoapparat.updateConfiguration(
+    configuration.copy(
+            flashMode = if (isChecked) torch() else off()
+            // all the parameters available in CameraConfiguration 
+    )
 )
 ```
 
 ## Switch cameras
 
-In order to switch between multiple instances of Fotoapparat, for example an instance using the device's front camera and another using the back, `FotoapparatSwitcher` can be used:
+In order to switch between cameras, `Fotoapparat.switchTo()` can be used with the new desired `lensPosition` and its `cameraConfiguration`.
 
-```java
-FotoapparatSwitcher fotoapparatSwitcher = FotoapparatSwitcher.withDefault(fotoapparatFront);
-fotoapparatSwitcher.switchTo(fotoapparatBack);
+```kotlin
+fotoapparat.switchTo(
+    lensPosition = front(),
+    cameraConfiguration = newConfigurationForFrontCamera
+)
 ```
 
 ## Set up
@@ -159,21 +166,36 @@ repositories {
   maven { url 'https://jitpack.io' }
 }
  
-compile 'io.fotoapparat.fotoapparat:library:1.5.0'
+implementation 'io.fotoapparat.fotoapparat:library:2.3.1'
 ```
 
 Camera permission will be automatically added to your `AndroidManifest.xml`. Do not forget to request this permission on Marshmallow and higher.
 
+#### Snapshot versions
+
+If you like to test and try the latest added features & bugfixes you can use the `-SNAPSHOT` version.
+Gradle will download & cache the latest snapshot version, so be sure to delete the cache if you want to try a newer `snapshot` version than the downloaded/cached one.
+
+```groovy
+implementation 'io.fotoapparat:fotoapparat:library:-SNAPSHOT'
+```
+
 ## Face detection
 
 Optionally, you can check out our other library which adds face detection capabilities - [FaceDetector](https://github.com/Fotoapparat/FaceDetector).
 
+## Videoapparat
+
+For video recording possibility, check out our premium library - [Videoapparat](https://github.com/Fotoapparat/Videoapparat)
+
+
 ## Credits
 
 We want to say thanks to [Mark Murphy](https://github.com/commonsguy) for the awesome job he did with [CWAC-Camera](https://github.com/commonsguy/cwac-camera). We were using his library for a couple of years and now we feel that Fotoapparat is a next step in the right direction.
 
 We also want to say many thanks to [Leander Lenzing](http://leanderlenzing.com/) for the amazing icon. Don't forget to follow his work in [dribbble](https://dribbble.com/leanderlenzing).
 
+
 ## License
 
 ```

build.gradle

@@ -1,17 +1,47 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
+    ext {
+        versions = [
+                gradle : '4.4.1',
+                kotlin : '1.2.51',
+                code   : 1,
+                name   : '1.0.0',
+                sdk    : [
+                        minimum: 14,
+                        target : 27
+                ],
+                android: [
+                        buildTools: '27.0.3',
+                        support   : '27.0.2'
+                ],
+                rx     : [
+                        rxJava1: '1.2.9',
+                        rxJava2: '2.0.8'
+                ],
+                test   : [
+                        junit  : '4.12',
+                        mockito: '2.13.0'
+                ],
+                util   : [
+                        commons: '2.5'
+                ]
+        ]
+    }
     repositories {
+        google()
         jcenter()
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:${project.androidBuildToolsVersion}"
+        classpath 'com.android.tools.build:gradle:3.1.3'
         classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}"
     }
 }
 
 allprojects {
     repositories {
+        google()
         jcenter()
     }
 }
@@ -21,5 +51,5 @@ task clean(type: Delete) {
 }
 
 task wrapper(type: Wrapper) {
-    gradleVersion = project.gradleVersion
+    gradleVersion = versions.gradle
 }

fotoapparat-adapters/README.md

@@ -5,6 +5,18 @@ The child modules contained herein are additional adapters for other popular exe
 
 To use, supply an instance of your desired adapter when performing a task of a PendingResult.
 
+Kotlin:
+```java
+fotoapparat.takePicture()
+	.toBitmap()
+	.toObservable()
+	.subscribe { bitmapPhoto ->
+			// Do something with the photo
+		}
+```
+
+
+Java:
 ```java
 fotoapparat.takePicture()
 	.toBitmap()
@@ -16,3 +28,12 @@ fotoapparat.takePicture()
 		}
 	});
 ```
+
+
+
+Supported types:
+
+ * `Observable<T>` : RxJava 1/2
+ * `Flowable<T>` : RxJava 2
+ * `Single<T>` : RxJava 1/2
+ * `Completable` : RxJava 1/2

fotoapparat-adapters/rxjava/build.gradle

@@ -1,23 +1,27 @@
 apply plugin: 'com.android.library'
 apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: 'kotlin-android'
 
 group = 'io.fotoapparat'
 
 android {
-    buildToolsVersion project.buildToolsVersion
-    compileSdkVersion Integer.parseInt(project.compileSdkVersion)
+    buildToolsVersion versions.android.buildTools
+    compileSdkVersion versions.sdk.target
 
     defaultConfig {
-        minSdkVersion Integer.parseInt(project.minSdkVersion)
-        targetSdkVersion Integer.parseInt(project.targetSdkVersion)
+        minSdkVersion versions.sdk.minimum
+        targetSdkVersion versions.sdk.target
 
         archivesBaseName = 'adapter-rxjava'
     }
 }
 
 dependencies {
-    compile project(':fotoapparat')
-    provided "io.reactivex:rxjava:${project.rxjava1Version}"
+    compileOnly project(':fotoapparat')
+    compileOnly "io.reactivex:rxjava:${versions.rx.rxJava1}"
 
-    testCompile "junit:junit:${project.junitVersion}"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}"
+
+    testImplementation "io.reactivex:rxjava:${versions.rx.rxJava1}"
+    testImplementation "junit:junit:${versions.test.junit}"
 }

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/CompletableAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import rx.Completable;
-
-/**
- * Adapter for {@link Completable}.
- */
-public class CompletableAdapter<T> implements Adapter<T, Completable> {
-
-    private CompletableAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Completable}.
-     */
-    public static <R> CompletableAdapter<R> toCompletable() {
-        return new CompletableAdapter<>();
-    }
-
-    @Override
-    public Completable adapt(Future<T> future) {
-        return Completable.fromFuture(future);
-    }
-}

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/CompletableAdapter.kt

@@ -0,0 +1,27 @@
+package io.fotoapparat.result.adapter.rxjava
+
+import io.fotoapparat.result.PendingResult
+import rx.Completable
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Completable].
+ */
+object CompletableAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Completable].
+     */
+    @JvmStatic
+    fun <T> toCompletable(): Function1<Future<T>, Completable> {
+        return { future -> Completable.fromFuture(future) }
+    }
+
+}
+
+/**
+ * @return A [Completable] from the given [PendingResult].
+ */
+fun <T> PendingResult<T>.toCompletable(): Completable {
+    return adapt { future -> Completable.fromFuture(future) }
+}

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/ObservableAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import rx.Observable;
-
-/**
- * Adapter for {@link Observable}.
- */
-public class ObservableAdapter<T> implements Adapter<T, Observable<T>> {
-
-    private ObservableAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Observable}.
-     */
-    public static <R> ObservableAdapter<R> toObservable() {
-        return new ObservableAdapter<>();
-    }
-
-    @Override
-    public Observable<T> adapt(Future<T> future) {
-        return Observable.from(future);
-    }
-}

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/ObservableAdapter.kt

@@ -0,0 +1,27 @@
+package io.fotoapparat.result.adapter.rxjava
+
+import io.fotoapparat.result.PendingResult
+import rx.Observable
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Observable].
+ */
+object ObservableAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Observable].
+     */
+    @JvmStatic
+    fun <T> toObservable(): Function1<Future<T>, Observable<T>> {
+        return { future -> Observable.from(future) }
+    }
+
+}
+
+/**
+ * @return A [Observable] from the given [PendingResult].
+ */
+fun <T> PendingResult<T>.toObservable(): Observable<T> {
+    return adapt { future -> Observable.from(future) }
+}

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/SingleAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import rx.Single;
-
-/**
- * Adapter for {@link Single}.
- */
-public class SingleAdapter<T> implements Adapter<T, Single<T>> {
-
-    private SingleAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Single}.
-     */
-    public static <R> SingleAdapter<R> toSingle() {
-        return new SingleAdapter<>();
-    }
-
-    @Override
-    public Single<T> adapt(Future<T> future) {
-        return Single.from(future);
-    }
-}

fotoapparat-adapters/rxjava/src/main/java/io/fotoapparat/result/adapter/rxjava/SingleAdapter.kt

@@ -0,0 +1,27 @@
+package io.fotoapparat.result.adapter.rxjava
+
+import io.fotoapparat.result.PendingResult
+import rx.Single
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Single].
+ */
+object SingleAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Single].
+     */
+    @JvmStatic
+    fun <T> toSingle(): (Future<T>) -> Single<T> {
+        return { future -> Single.from(future) }
+    }
+
+}
+
+/**
+ * @return A [Single] from the given [PendingResult].
+ */
+fun <T> PendingResult<T>.toSingle(): Single<T> {
+    return adapt { future -> Single.from(future) }
+}

fotoapparat-adapters/rxjava/src/test/java/io/fotoapparat/result/adapter/rxjava/CallableFuture.java

@@ -1,58 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava;
-
-import android.support.annotation.NonNull;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * Simply returns the value of the callable.
- */
-public class CallableFuture<T> implements Future<T> {
-
-    private final CountDownLatch latch = new CountDownLatch(1);
-    private final Callable<T> callable;
-
-    public CallableFuture(Callable<T> callable) {
-        this.callable = callable;
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return false;
-    }
-
-    @Override
-    public boolean isDone() {
-        return latch.getCount() == 0;
-    }
-
-    @Override
-    public T get() throws InterruptedException, ExecutionException {
-        return callCallable();
-    }
-
-    @Override
-    public T get(long timeout,
-                 @NonNull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        return callCallable();
-    }
-
-    private T callCallable() throws ExecutionException {
-        latch.countDown();
-        try {
-            return callable.call();
-        } catch (Exception e) {
-            throw new ExecutionException(e);
-        }
-    }
-}

fotoapparat-adapters/rxjava/src/test/java/io/fotoapparat/result/adapter/rxjava/CallableFuture.kt

@@ -0,0 +1,44 @@
+package io.fotoapparat.result.adapter.rxjava
+
+import java.util.concurrent.*
+
+/**
+ * Simply returns the value of the callable.
+ */
+class CallableFuture<T>(private val callable: Callable<T>) : Future<T> {
+
+    private val latch = CountDownLatch(1)
+
+    override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
+        return false
+    }
+
+    override fun isCancelled(): Boolean {
+        return false
+    }
+
+    override fun isDone(): Boolean {
+        return latch.count == 0L
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class)
+    override fun get(): T {
+        return callCallable()
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class, TimeoutException::class)
+    override fun get(timeout: Long, unit: TimeUnit): T {
+        return callCallable()
+    }
+
+    @Throws(ExecutionException::class)
+    private fun callCallable(): T {
+        latch.countDown()
+        try {
+            return callable.call()
+        } catch (e: Exception) {
+            throw ExecutionException(e)
+        }
+
+    }
+}

fotoapparat-adapters/rxjava/src/test/java/io/fotoapparat/result/adapter/rxjava/CompletableAdapterTest.java

@@ -24,7 +24,7 @@ public class CompletableAdapterTest {
 
         // When
         CompletableAdapter.<String>toCompletable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then
@@ -45,7 +45,7 @@ public class CompletableAdapterTest {
 
         // When
         CompletableAdapter.<String>toCompletable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then

fotoapparat-adapters/rxjava/src/test/java/io/fotoapparat/result/adapter/rxjava/ObservableAdapterTest.java

@@ -24,7 +24,7 @@ public class ObservableAdapterTest {
 
         // When
         ObservableAdapter.<String>toObservable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then
@@ -45,7 +45,7 @@ public class ObservableAdapterTest {
 
         // When
         ObservableAdapter.<String>toObservable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then

fotoapparat-adapters/rxjava/src/test/java/io/fotoapparat/result/adapter/rxjava/SingleAdapterTest.java

@@ -24,7 +24,7 @@ public class SingleAdapterTest {
 
         // When
         SingleAdapter.<String>toSingle()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then
@@ -45,7 +45,7 @@ public class SingleAdapterTest {
 
         // When
         SingleAdapter.<String>toSingle()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(subscriber);
 
         // Then

fotoapparat-adapters/rxjava2/README.md

@@ -5,6 +5,7 @@ An `Adapter` for adapting RxJava 2.x types.
 Available types:
 
  * `Observable<T>`
+ * `Flowable<T>`
  * `Single<T>`
  * `Completable`
 

fotoapparat-adapters/rxjava2/build.gradle

@@ -1,23 +1,27 @@
 apply plugin: 'com.android.library'
 apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: 'kotlin-android'
 
 group = 'io.fotoapparat'
 
 android {
-    buildToolsVersion project.buildToolsVersion
-    compileSdkVersion Integer.parseInt(project.compileSdkVersion)
+    buildToolsVersion versions.android.buildTools
+    compileSdkVersion versions.sdk.target
 
     defaultConfig {
-        minSdkVersion Integer.parseInt(project.minSdkVersion)
-        targetSdkVersion Integer.parseInt(project.targetSdkVersion)
+        minSdkVersion versions.sdk.minimum
+        targetSdkVersion versions.sdk.target
 
         archivesBaseName = 'adapter-rxjava2'
     }
 }
 
 dependencies {
-    compile project(':fotoapparat')
-    provided "io.reactivex.rxjava2:rxjava:${project.rxjava2Version}"
+    compileOnly project(':fotoapparat')
+    compileOnly "io.reactivex.rxjava2:rxjava:${versions.rx.rxJava2}"
 
-    testCompile "junit:junit:${project.junitVersion}"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}"
+
+    testImplementation "io.reactivex.rxjava2:rxjava:${versions.rx.rxJava2}"
+    testImplementation "junit:junit:${versions.test.junit}"
 }

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/CompletableAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava2;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import io.reactivex.Completable;
-
-/**
- * Adapter for {@link Completable}.
- */
-public class CompletableAdapter<T> implements Adapter<T, Completable> {
-
-    private CompletableAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Completable}.
-     */
-    public static <R> CompletableAdapter<R> toCompletable() {
-        return new CompletableAdapter<>();
-    }
-
-    @Override
-    public Completable adapt(Future<T> future) {
-        return Completable.fromFuture(future);
-    }
-}

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/CompletableAdapter.kt

@@ -0,0 +1,31 @@
+package io.fotoapparat.result.adapter.rxjava2
+
+import android.annotation.SuppressLint
+import io.fotoapparat.result.PendingResult
+import io.reactivex.Completable
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Completable].
+ */
+object CompletableAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Completable].
+     */
+    @JvmStatic
+    @SuppressLint("CheckResult")
+    fun <R> toCompletable(): (Future<R>) -> Completable {
+        return { future -> Completable.fromFuture(future) }
+    }
+
+}
+
+/**
+ * @return A [Completable] from the given [PendingResult].
+ */
+@SuppressLint("CheckResult")
+fun <T> PendingResult<T>.toCompletable(): Completable {
+    return adapt { future -> Completable.fromFuture(future) }
+}
+

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/FlowableAdapter.kt

@@ -0,0 +1,30 @@
+package io.fotoapparat.result.adapter.rxjava2
+
+import android.annotation.SuppressLint
+import io.fotoapparat.result.PendingResult
+import io.reactivex.Flowable
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Flowable].
+ */
+object FlowableAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Flowable].
+     */
+    @JvmStatic
+    @SuppressLint("CheckResult")
+    fun <T> toFlowable(): Function1<Future<T>, Flowable<T>> {
+        return { future -> Flowable.fromFuture(future) }
+    }
+
+}
+
+/**
+ * @return A [Flowable] from the given [PendingResult].
+ */
+@SuppressLint("CheckResult")
+fun <T> PendingResult<T>.toFlowable(): Flowable<T> {
+    return adapt { future -> Flowable.fromFuture(future) }
+}

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/ObservableAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava2;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import io.reactivex.Observable;
-
-/**
- * Adapter for {@link Observable}.
- */
-public class ObservableAdapter<T> implements Adapter<T, Observable<T>> {
-
-    private ObservableAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Observable}.
-     */
-    public static <R> ObservableAdapter<R> toObservable() {
-        return new ObservableAdapter<>();
-    }
-
-    @Override
-    public Observable<T> adapt(Future<T> future) {
-        return Observable.fromFuture(future);
-    }
-}

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/ObservableAdapter.kt

@@ -0,0 +1,30 @@
+package io.fotoapparat.result.adapter.rxjava2
+
+import android.annotation.SuppressLint
+import io.fotoapparat.result.PendingResult
+import io.reactivex.Observable
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Observable].
+ */
+object ObservableAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Observable].
+     */
+    @JvmStatic
+    @SuppressLint("CheckResult")
+    fun <T> toObservable(): Function1<Future<T>, Observable<T>> {
+        return { future -> Observable.fromFuture(future) }
+    }
+
+}
+
+/**
+ * @return A [Observable] from the given [PendingResult].
+ */
+@SuppressLint("CheckResult")
+fun <T> PendingResult<T>.toObservable(): Observable<T> {
+    return adapt { future -> Observable.fromFuture(future) }
+}

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/SingleAdapter.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava2;
-
-import java.util.concurrent.Future;
-
-import io.fotoapparat.result.adapter.Adapter;
-import io.reactivex.Single;
-
-/**
- * Adapter for {@link Single}.
- */
-public class SingleAdapter<T> implements Adapter<T, Single<T>> {
-
-    private SingleAdapter() {
-    }
-
-    /**
-     * @return {@link Adapter} which adapts result to {@link Single}.
-     */
-    public static <R> SingleAdapter<R> toSingle() {
-        return new SingleAdapter<>();
-    }
-
-    @Override
-    public Single<T> adapt(Future<T> future) {
-        return Single.fromFuture(future);
-    }
-}

fotoapparat-adapters/rxjava2/src/main/java/io/fotoapparat/result/adapter/rxjava2/SingleAdapter.kt

@@ -0,0 +1,30 @@
+package io.fotoapparat.result.adapter.rxjava2
+
+import android.annotation.SuppressLint
+import io.fotoapparat.result.PendingResult
+import io.reactivex.Single
+import java.util.concurrent.Future
+
+/**
+ * Adapter for [Single].
+ */
+object SingleAdapter {
+
+    /**
+     * @return Adapter which adapts result to [Single].
+     */
+    @JvmStatic
+    @SuppressLint("CheckResult")
+    fun <T> toSingle(): (Future<T>) -> Single<T> {
+        return { future -> Single.fromFuture(future) }
+    }
+
+}
+
+/**
+ * @return A [Single] from the given [PendingResult].
+ */
+@SuppressLint("CheckResult")
+fun <T> PendingResult<T>.toSingle(): Single<T> {
+    return adapt { future -> Single.fromFuture(future) }
+}

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/CallableFuture.java

@@ -1,58 +0,0 @@
-package io.fotoapparat.result.adapter.rxjava2;
-
-import android.support.annotation.NonNull;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-/**
- * Simply returns the value of the callable.
- */
-public class CallableFuture<T> implements Future<T> {
-
-    private final CountDownLatch latch = new CountDownLatch(1);
-    private final Callable<T> callable;
-
-    public CallableFuture(Callable<T> callable) {
-        this.callable = callable;
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return false;
-    }
-
-    @Override
-    public boolean isDone() {
-        return latch.getCount() == 0;
-    }
-
-    @Override
-    public T get() throws InterruptedException, ExecutionException {
-        return callCallable();
-    }
-
-    @Override
-    public T get(long timeout,
-                 @NonNull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        return callCallable();
-    }
-
-    private T callCallable() throws ExecutionException {
-        latch.countDown();
-        try {
-            return callable.call();
-        } catch (Exception e) {
-            throw new ExecutionException(e);
-        }
-    }
-}

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/CallableFuture.kt

@@ -0,0 +1,44 @@
+package io.fotoapparat.result.adapter.rxjava2
+
+import java.util.concurrent.*
+
+/**
+ * Simply returns the value of the callable.
+ */
+class CallableFuture<T>(private val callable: Callable<T>) : Future<T> {
+
+    private val latch = CountDownLatch(1)
+
+    override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
+        return false
+    }
+
+    override fun isCancelled(): Boolean {
+        return false
+    }
+
+    override fun isDone(): Boolean {
+        return latch.count == 0L
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class)
+    override fun get(): T {
+        return callCallable()
+    }
+
+    @Throws(InterruptedException::class, ExecutionException::class, TimeoutException::class)
+    override fun get(timeout: Long, unit: TimeUnit): T {
+        return callCallable()
+    }
+
+    @Throws(ExecutionException::class)
+    private fun callCallable(): T {
+        latch.countDown()
+        try {
+            return callable.call()
+        } catch (e: Exception) {
+            throw ExecutionException(e)
+        }
+
+    }
+}

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/CompletableAdapterTest.java

@@ -10,7 +10,7 @@ import io.reactivex.observers.TestObserver;
 
 public class CompletableAdapterTest {
 
-    private TestObserver<Object> observer = new TestObserver<>();
+    private TestObserver<String> observer = new TestObserver<>();
 
     @Test
     public void completed() throws Exception {
@@ -24,7 +24,7 @@ public class CompletableAdapterTest {
 
         // When
         CompletableAdapter.<String>toCompletable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then
@@ -44,7 +44,7 @@ public class CompletableAdapterTest {
 
         // When
         CompletableAdapter.<String>toCompletable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/FlowableAdapterTest.java

@@ -0,0 +1,55 @@
+package io.fotoapparat.result.adapter.rxjava2;
+
+import org.junit.Test;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import io.reactivex.subscribers.TestSubscriber;
+
+public class FlowableAdapterTest {
+
+    private TestSubscriber<String> observer = new TestSubscriber<>();
+
+    @Test
+    public void completed() throws Exception {
+        // Given
+        Future<String> future = new CallableFuture<>(new Callable<String>() {
+            @Override
+            public String call() throws Exception {
+                return "Hello";
+            }
+        });
+
+        // When
+        FlowableAdapter.<String>toFlowable()
+                .invoke(future)
+                .subscribe(observer);
+
+        // Then
+        observer.assertValue("Hello");
+        observer.assertNoErrors();
+    }
+
+    @Test
+    public void error() throws Exception {
+        // Given
+        Future<String> future = new CallableFuture<>(new Callable<String>() {
+            @Override
+            public String call() throws Exception {
+                throw new RuntimeException("What a failure");
+            }
+        });
+
+        // When
+        FlowableAdapter.<String>toFlowable()
+                .invoke(future)
+                .subscribe(observer);
+
+        // Then
+        observer.assertNoValues();
+        observer.assertError(ExecutionException.class);
+    }
+
+}

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/ObservableAdapterTest.java

@@ -10,7 +10,7 @@ import io.reactivex.observers.TestObserver;
 
 public class ObservableAdapterTest {
 
-    private TestObserver<Object> observer = new TestObserver<>();
+    private TestObserver<String> observer = new TestObserver<>();
 
     @Test
     public void completed() throws Exception {
@@ -24,7 +24,7 @@ public class ObservableAdapterTest {
 
         // When
         ObservableAdapter.<String>toObservable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then
@@ -44,7 +44,7 @@ public class ObservableAdapterTest {
 
         // When
         ObservableAdapter.<String>toObservable()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then

fotoapparat-adapters/rxjava2/src/test/java/io/fotoapparat/result/adapter/rxjava2/SingleAdapterTest.java

@@ -10,7 +10,7 @@ import io.reactivex.observers.TestObserver;
 
 public class SingleAdapterTest {
 
-    private TestObserver<Object> observer = new TestObserver<>();
+    private TestObserver<String> observer = new TestObserver<>();
 
     @Test
     public void completed() throws Exception {
@@ -24,7 +24,7 @@ public class SingleAdapterTest {
 
         // When
         SingleAdapter.<String>toSingle()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then
@@ -44,7 +44,7 @@ public class SingleAdapterTest {
 
         // When
         SingleAdapter.<String>toSingle()
-                .adapt(future)
+                .invoke(future)
                 .subscribe(observer);
 
         // Then

fotoapparat/build.gradle

@@ -1,15 +1,18 @@
 apply plugin: 'com.android.library'
 apply plugin: 'com.github.dcendents.android-maven'
+apply plugin: 'kotlin-android'
 
 group = 'io.fotoapparat'
 
+kotlin.experimental.coroutines 'enable'
+
 android {
-    buildToolsVersion project.buildToolsVersion
-    compileSdkVersion Integer.parseInt(project.compileSdkVersion)
+    buildToolsVersion versions.android.buildTools
+    compileSdkVersion versions.sdk.target
 
     defaultConfig {
-        minSdkVersion Integer.parseInt(project.minSdkVersion)
-        targetSdkVersion Integer.parseInt(project.targetSdkVersion)
+        minSdkVersion versions.sdk.minimum
+        targetSdkVersion versions.sdk.target
 
         archivesBaseName = 'library'
     }
@@ -26,9 +29,12 @@ android {
 }
 
 dependencies {
-    compile "com.android.support:support-annotations:${project.appCompatVersion}"
+    compile "com.android.support:support-annotations:${versions.android.support}"
+    compile "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}"
+    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.21'
 
-    testCompile "junit:junit:${project.junitVersion}"
-    testCompile "org.mockito:mockito-core:${project.mockitoVersion}"
-    testCompile 'commons-io:commons-io:2.5'
+    testImplementation "junit:junit:${versions.test.junit}"
+    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:${versions.kotlin}"
+    testImplementation "org.mockito:mockito-core:${versions.test.mockito}"
+    testImplementation "commons-io:commons-io:${versions.util.commons}"
 }

fotoapparat/src/main/java/io/fotoapparat/Fotoapparat.java

@@ -1,342 +0,0 @@
-package io.fotoapparat;
-
-import android.content.Context;
-import android.support.annotation.FloatRange;
-import android.support.annotation.NonNull;
-
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-
-import io.fotoapparat.error.Callbacks;
-import io.fotoapparat.error.CameraErrorCallback;
-import io.fotoapparat.hardware.CameraDevice;
-import io.fotoapparat.hardware.orientation.OrientationSensor;
-import io.fotoapparat.hardware.orientation.RotationListener;
-import io.fotoapparat.hardware.orientation.ScreenOrientationProvider;
-import io.fotoapparat.parameter.provider.CapabilitiesProvider;
-import io.fotoapparat.parameter.provider.CurrentParametersProvider;
-import io.fotoapparat.parameter.provider.InitialParametersProvider;
-import io.fotoapparat.parameter.provider.InitialParametersValidator;
-import io.fotoapparat.parameter.update.UpdateRequest;
-import io.fotoapparat.result.CapabilitiesResult;
-import io.fotoapparat.result.FocusResult;
-import io.fotoapparat.result.ParametersResult;
-import io.fotoapparat.result.PendingResult;
-import io.fotoapparat.result.PhotoResult;
-import io.fotoapparat.routine.CheckAvailabilityRoutine;
-import io.fotoapparat.routine.ConfigurePreviewStreamRoutine;
-import io.fotoapparat.routine.StartCameraRoutine;
-import io.fotoapparat.routine.StopCameraRoutine;
-import io.fotoapparat.routine.UpdateOrientationRoutine;
-import io.fotoapparat.routine.focus.AutoFocusRoutine;
-import io.fotoapparat.routine.parameter.UpdateParametersRoutine;
-import io.fotoapparat.routine.picture.TakePictureRoutine;
-import io.fotoapparat.routine.zoom.UpdateZoomLevelRoutine;
-
-/**
- * Camera. Takes pictures.
- */
-public class Fotoapparat {
-
-    private static final Executor SERIAL_EXECUTOR = Executors.newSingleThreadExecutor();
-
-    private final StartCameraRoutine startCameraRoutine;
-    private final StopCameraRoutine stopCameraRoutine;
-    private final UpdateOrientationRoutine updateOrientationRoutine;
-    private final ConfigurePreviewStreamRoutine configurePreviewStreamRoutine;
-    private final CapabilitiesProvider capabilitiesProvider;
-    private final CurrentParametersProvider currentParametersProvider;
-    private final TakePictureRoutine takePictureRoutine;
-    private final AutoFocusRoutine autoFocusRoutine;
-    private final CheckAvailabilityRoutine checkAvailabilityRoutine;
-    private final UpdateParametersRoutine updateParametersRoutine;
-    private final UpdateZoomLevelRoutine updateZoomLevelRoutine;
-    private final Executor executor;
-
-    private boolean started = false;
-
-    Fotoapparat(StartCameraRoutine startCameraRoutine,
-                StopCameraRoutine stopCameraRoutine,
-                UpdateOrientationRoutine updateOrientationRoutine,
-                ConfigurePreviewStreamRoutine configurePreviewStreamRoutine,
-                CapabilitiesProvider capabilitiesProvider,
-                CurrentParametersProvider parametersProvider,
-                TakePictureRoutine takePictureRoutine,
-                AutoFocusRoutine autoFocusRoutine,
-                CheckAvailabilityRoutine checkAvailabilityRoutine,
-                UpdateParametersRoutine updateParametersRoutine,
-                UpdateZoomLevelRoutine updateZoomLevelRoutine,
-                Executor executor) {
-        this.startCameraRoutine = startCameraRoutine;
-        this.stopCameraRoutine = stopCameraRoutine;
-        this.updateOrientationRoutine = updateOrientationRoutine;
-        this.configurePreviewStreamRoutine = configurePreviewStreamRoutine;
-        this.capabilitiesProvider = capabilitiesProvider;
-        this.currentParametersProvider = parametersProvider;
-        this.takePictureRoutine = takePictureRoutine;
-        this.autoFocusRoutine = autoFocusRoutine;
-        this.checkAvailabilityRoutine = checkAvailabilityRoutine;
-        this.updateParametersRoutine = updateParametersRoutine;
-        this.updateZoomLevelRoutine = updateZoomLevelRoutine;
-        this.executor = executor;
-    }
-
-    public static FotoapparatBuilder with(Context context) {
-        if (context == null) {
-            throw new IllegalStateException("Context is null.");
-        }
-
-        return new FotoapparatBuilder(context);
-    }
-
-    static Fotoapparat create(FotoapparatBuilder builder) {
-        CameraErrorCallback cameraErrorCallback = Callbacks.onMainThread(
-                builder.cameraErrorCallback
-        );
-
-        CameraDevice cameraDevice = builder.cameraProvider.get(builder.logger);
-
-        ScreenOrientationProvider screenOrientationProvider = new ScreenOrientationProvider(builder.context);
-        RotationListener rotationListener = new RotationListener(builder.context);
-
-        InitialParametersValidator parametersValidator = new InitialParametersValidator();
-        InitialParametersProvider initialParametersProvider = new InitialParametersProvider(
-                cameraDevice,
-                builder.photoSizeSelector,
-                builder.previewSizeSelector,
-                builder.focusModeSelector,
-                builder.flashSelector,
-                builder.previewFpsRangeSelector,
-                builder.sensorSensitivitySelector,
-                builder.jpegQuality,
-                parametersValidator
-        );
-
-        StartCameraRoutine startCameraRoutine = new StartCameraRoutine(
-                cameraDevice,
-                builder.renderer,
-                builder.scaleType,
-                builder.lensPositionSelector,
-                screenOrientationProvider,
-                initialParametersProvider,
-                cameraErrorCallback
-        );
-
-        StopCameraRoutine stopCameraRoutine = new StopCameraRoutine(cameraDevice);
-
-        OrientationSensor orientationSensor = new OrientationSensor(
-                rotationListener,
-                screenOrientationProvider
-        );
-
-        UpdateOrientationRoutine updateOrientationRoutine = new UpdateOrientationRoutine(
-                cameraDevice,
-                orientationSensor,
-                SERIAL_EXECUTOR,
-                builder.logger
-        );
-
-        ConfigurePreviewStreamRoutine configurePreviewStreamRoutine = new ConfigurePreviewStreamRoutine(
-                cameraDevice,
-                builder.frameProcessor
-        );
-
-        CapabilitiesProvider capabilitiesProvider = new CapabilitiesProvider(
-                cameraDevice,
-                SERIAL_EXECUTOR
-        );
-
-        CurrentParametersProvider currentParametersProvider = new CurrentParametersProvider(
-                cameraDevice,
-                SERIAL_EXECUTOR
-        );
-
-        TakePictureRoutine takePictureRoutine = new TakePictureRoutine(
-                cameraDevice,
-                SERIAL_EXECUTOR
-        );
-
-        AutoFocusRoutine autoFocusRoutine = new AutoFocusRoutine(
-                cameraDevice,
-                SERIAL_EXECUTOR
-        );
-
-        CheckAvailabilityRoutine checkAvailabilityRoutine = new CheckAvailabilityRoutine(
-                cameraDevice,
-                builder.lensPositionSelector
-        );
-
-        UpdateParametersRoutine updateParametersRoutine = new UpdateParametersRoutine(
-                cameraDevice
-        );
-
-        UpdateZoomLevelRoutine updateZoomLevelRoutine = new UpdateZoomLevelRoutine(
-                cameraDevice
-        );
-
-        return new Fotoapparat(
-                startCameraRoutine,
-                stopCameraRoutine,
-                updateOrientationRoutine,
-                configurePreviewStreamRoutine,
-                capabilitiesProvider,
-                currentParametersProvider,
-                takePictureRoutine,
-                autoFocusRoutine,
-                checkAvailabilityRoutine,
-                updateParametersRoutine,
-                updateZoomLevelRoutine,
-                SERIAL_EXECUTOR
-        );
-    }
-
-    /**
-     * @return {@code true} if camera for this {@link Fotoapparat} is available. {@code false} if
-     * it is not available.
-     */
-    public boolean isAvailable() {
-        return checkAvailabilityRoutine.isAvailable();
-    }
-
-    /**
-     * Provides camera capabilities asynchronously, returns immediately.
-     *
-     * @return {@link CapabilitiesResult} which will deliver result asynchronously.
-     */
-    public CapabilitiesResult getCapabilities() {
-        ensureStarted();
-
-        return capabilitiesProvider.getCapabilities();
-    }
-
-    /**
-     * Provides current camera parameters asynchronously, returns immediately.
-     *
-     * @return {@link ParametersResult} which will deliver result asynchronously.
-     */
-    public ParametersResult getCurrentParameters() {
-        ensureStarted();
-
-        return currentParametersProvider.getParameters();
-    }
-
-    /**
-     * Takes picture. Returns immediately.
-     *
-     * @return {@link PhotoResult} which will deliver result asynchronously.
-     */
-    public PhotoResult takePicture() {
-        ensureStarted();
-
-        return takePictureRoutine.takePicture();
-    }
-
-    /**
-     * Performs auto focus. If it is not available or not enabled, does nothing.
-     */
-    public Fotoapparat autoFocus() {
-        focus();
-
-        return this;
-    }
-
-    /**
-     * Attempts to focus the camera asynchronously.
-     *
-     * @return the pending result of focus operation which will deliver result asynchronously.
-     */
-    public PendingResult<FocusResult> focus() {
-        ensureStarted();
-
-        return autoFocusRoutine.autoFocus();
-    }
-
-    /**
-     * Asynchronously updates parameters of the camera. Must be called only after {@link #start()}.
-     */
-    public void updateParameters(@NonNull final UpdateRequest updateRequest) {
-        ensureStarted();
-
-        executor.execute(new Runnable() {
-            @Override
-            public void run() {
-                updateParametersRoutine.updateParameters(updateRequest);
-            }
-        });
-    }
-
-    /**
-     * Asynchronously updates zoom level of the camera. Must be called only after {@link #start()}.
-     * <p>
-     * If zoom is not supported by the device - does nothing.
-     *
-     * @param zoomLevel zoom level of the camera. A value between 0 and 1.
-     */
-    public void setZoom(@FloatRange(from = 0f, to = 1f) final float zoomLevel) {
-        ensureStarted();
-
-        executor.execute(new Runnable() {
-            @Override
-            public void run() {
-                updateZoomLevelRoutine.updateZoomLevel(zoomLevel);
-            }
-        });
-    }
-
-    /**
-     * Starts camera.
-     *
-     * @throws IllegalStateException if camera was already started.
-     */
-    public void start() {
-        ensureNotStarted();
-        started = true;
-
-        startCamera();
-        configurePreviewStream();
-        updateOrientationRoutine.start();
-    }
-
-    /**
-     * Stops camera.
-     *
-     * @throws IllegalStateException if camera is not started.
-     */
-    public void stop() {
-        ensureStarted();
-        started = false;
-
-        updateOrientationRoutine.stop();
-        stopCamera();
-    }
-
-    private void startCamera() {
-        executor.execute(
-                startCameraRoutine
-        );
-    }
-
-    private void stopCamera() {
-        executor.execute(
-                stopCameraRoutine
-        );
-    }
-
-    private void configurePreviewStream() {
-        executor.execute(
-                configurePreviewStreamRoutine
-        );
-    }
-
-    private void ensureStarted() {
-        if (!started) {
-            throw new IllegalStateException("Camera is not started!");
-        }
-    }
-
-    private void ensureNotStarted() {
-        if (started) {
-            throw new IllegalStateException("Camera is already started!");
-        }
-    }
-}

fotoapparat/src/main/java/io/fotoapparat/Fotoapparat.kt

@@ -0,0 +1,245 @@
+package io.fotoapparat
+
+import android.content.Context
+import android.support.annotation.FloatRange
+import io.fotoapparat.concurrent.CameraExecutor
+import io.fotoapparat.concurrent.CameraExecutor.Operation
+import io.fotoapparat.configuration.CameraConfiguration
+import io.fotoapparat.configuration.Configuration
+import io.fotoapparat.error.CameraErrorCallback
+import io.fotoapparat.error.onMainThread
+import io.fotoapparat.hardware.Device
+import io.fotoapparat.hardware.display.Display
+import io.fotoapparat.hardware.orientation.OrientationSensor
+import io.fotoapparat.log.Logger
+import io.fotoapparat.log.none
+import io.fotoapparat.parameter.ScaleType
+import io.fotoapparat.result.*
+import io.fotoapparat.routine.camera.bootStart
+import io.fotoapparat.routine.camera.shutDown
+import io.fotoapparat.routine.camera.switchCamera
+import io.fotoapparat.routine.camera.updateDeviceConfiguration
+import io.fotoapparat.routine.capability.getCapabilities
+import io.fotoapparat.routine.focus.focus
+import io.fotoapparat.routine.parameter.getCurrentParameters
+import io.fotoapparat.routine.photo.takePhoto
+import io.fotoapparat.routine.zoom.updateZoomLevel
+import io.fotoapparat.selector.*
+import io.fotoapparat.view.CameraRenderer
+import io.fotoapparat.view.FocalPointSelector
+
+/**
+ * Camera. Takes pictures.
+ */
+class Fotoapparat
+@JvmOverloads constructor(
+        context: Context,
+        view: CameraRenderer,
+        focusView: FocalPointSelector? = null,
+        lensPosition: LensPositionSelector = firstAvailable(
+                back(),
+                front(),
+                external()
+        ),
+        scaleType: ScaleType = ScaleType.CenterCrop,
+        cameraConfiguration: CameraConfiguration = CameraConfiguration.default(),
+        cameraErrorCallback: CameraErrorCallback = {},
+        private val executor: CameraExecutor = EXECUTOR,
+        private val logger: Logger = none()
+) {
+
+    private val mainThreadErrorCallback = cameraErrorCallback.onMainThread()
+
+    private val display = Display(context)
+
+    private val device = Device(
+            cameraRenderer = view,
+            focusPointSelector = focusView,
+            logger = logger,
+            display = display,
+            scaleType = scaleType,
+            initialLensPositionSelector = lensPosition,
+            initialConfiguration = cameraConfiguration,
+            executor = executor
+    )
+
+    private val orientationSensor = OrientationSensor(
+            context = context,
+            device = device
+    )
+
+    init {
+        logger.recordMethod()
+    }
+
+    /**
+     * Starts camera.
+     *
+     * @throws IllegalStateException If the camera has already started.
+     */
+    fun start() {
+        logger.recordMethod()
+
+        executor.execute(Operation {
+            device.bootStart(
+                    orientationSensor = orientationSensor,
+                    mainThreadErrorCallback = mainThreadErrorCallback
+            )
+        })
+    }
+
+    /**
+     * Stops camera.
+     *
+     * @throws IllegalStateException If the camera has not started.
+     */
+    fun stop() {
+        logger.recordMethod()
+
+        executor.cancelTasks()
+        executor.execute(Operation {
+            device.shutDown(
+                    orientationSensor = orientationSensor
+            )
+        })
+    }
+
+    /**
+     * Takes picture, returns immediately.
+     *
+     * @return [PhotoResult] which will deliver result asynchronously.
+     */
+    fun takePicture(): PhotoResult {
+        logger.recordMethod()
+
+        val future = executor.execute(Operation(
+                cancellable = true,
+                function = device::takePhoto
+        ))
+
+        return PhotoResult.fromFuture(future, logger)
+    }
+
+    /**
+     * Provides camera capabilities asynchronously, returns immediately.
+     *
+     * @return [CapabilitiesResult] which will deliver result asynchronously.
+     */
+    fun getCapabilities(): CapabilitiesResult {
+        logger.recordMethod()
+
+        val future = executor.execute(Operation(
+                cancellable = true,
+                function = device::getCapabilities
+        ))
+
+        return PendingResult.fromFuture(future, logger)
+    }
+
+    /**
+     * Provides current camera parameters asynchronously, returns immediately.
+     *
+     * @return [ParametersResult] which will deliver result asynchronously.
+     */
+    fun getCurrentParameters(): ParametersResult {
+        logger.recordMethod()
+
+        val future = executor.execute(Operation(
+                cancellable = true,
+                function = device::getCurrentParameters
+        ))
+
+        return PendingResult.fromFuture(future, logger)
+    }
+
+    /**
+     * Updates current configuration.
+     *
+     * @throws IllegalStateException If the current camera has not started.
+     */
+    fun updateConfiguration(newConfiguration: Configuration) = executor.execute(
+            Operation(cancellable = true) {
+                logger.recordMethod()
+
+                device.updateDeviceConfiguration(newConfiguration)
+            })
+
+    /**
+     * Asynchronously updates zoom level of the camera.
+     * If zoom is not supported by the device - does nothing.
+     *
+     * @param zoomLevel Zoom level of the camera. A value between 0 and 1.
+     * @throws IllegalStateException If the current camera has not started.
+     */
+    fun setZoom(@FloatRange(from = 0.0, to = 1.0) zoomLevel: Float) = executor.execute(
+            Operation(cancellable = true) {
+                logger.recordMethod()
+
+                device.updateZoomLevel(
+                        zoomLevel = zoomLevel
+                )
+            })
+
+    /**
+     * Performs auto focus. If it is not available or not enabled, does nothing.
+     *
+     * @see Fotoapparat.focus
+     */
+    fun autoFocus(): Fotoapparat = apply {
+        logger.recordMethod()
+        focus()
+    }
+
+    /**
+     * Attempts to focus the camera asynchronously.
+     *
+     * @return the pending result of focus operation which will deliver result asynchronously.
+     *
+     * @see Fotoapparat.autoFocus
+     */
+    fun focus(): PendingResult<FocusResult> {
+        logger.recordMethod()
+
+        val future = executor.execute(Operation(
+                cancellable = true,
+                function = device::focus
+        ))
+
+        return PendingResult.fromFuture(future, logger)
+    }
+
+    /**
+     * Switches to another camera. If previous camera has already started then it will be
+     * stopped automatically and new will start.
+     */
+    fun switchTo(
+            lensPosition: LensPositionSelector,
+            cameraConfiguration: CameraConfiguration
+    ) {
+        logger.recordMethod()
+
+        executor.execute(Operation(cancellable = true) {
+            device.switchCamera(
+                    newLensPositionSelector = lensPosition,
+                    newConfiguration = cameraConfiguration,
+                    mainThreadErrorCallback = mainThreadErrorCallback
+            )
+        })
+    }
+
+    /**
+     * @return `true` if selected lens position is available. `false` if it is not available.
+     */
+    fun isAvailable(
+            selector: LensPositionSelector
+    ): Boolean = device.canSelectCamera(selector)
+
+    companion object {
+
+        private val EXECUTOR = CameraExecutor()
+
+        @JvmStatic
+        fun with(context: Context): FotoapparatBuilder = FotoapparatBuilder(context)
+
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/FotoapparatBuilder.java

@@ -1,220 +0,0 @@
-package io.fotoapparat;
-
-import android.content.Context;
-import android.support.annotation.IntRange;
-import android.support.annotation.NonNull;
-
-import io.fotoapparat.error.CameraErrorCallback;
-import java.util.Collection;
-
-import io.fotoapparat.hardware.CameraDevice;
-import io.fotoapparat.hardware.provider.CameraProvider;
-import io.fotoapparat.log.Logger;
-import io.fotoapparat.log.Loggers;
-import io.fotoapparat.parameter.Flash;
-import io.fotoapparat.parameter.FocusMode;
-import io.fotoapparat.parameter.LensPosition;
-import io.fotoapparat.parameter.ScaleType;
-import io.fotoapparat.parameter.Size;
-import io.fotoapparat.parameter.range.Range;
-import io.fotoapparat.parameter.selector.FlashSelectors;
-import io.fotoapparat.parameter.selector.SelectorFunction;
-import io.fotoapparat.parameter.selector.Selectors;
-import io.fotoapparat.preview.FrameProcessor;
-import io.fotoapparat.view.CameraRenderer;
-import io.fotoapparat.view.CameraView;
-
-import static io.fotoapparat.hardware.provider.CameraProviders.v1;
-import static io.fotoapparat.parameter.selector.FocusModeSelectors.autoFocus;
-import static io.fotoapparat.parameter.selector.FocusModeSelectors.continuousFocus;
-import static io.fotoapparat.parameter.selector.FocusModeSelectors.fixed;
-import static io.fotoapparat.parameter.selector.LensPositionSelectors.back;
-import static io.fotoapparat.parameter.selector.LensPositionSelectors.external;
-import static io.fotoapparat.parameter.selector.LensPositionSelectors.front;
-import static io.fotoapparat.parameter.selector.Selectors.firstAvailable;
-import static io.fotoapparat.parameter.selector.SizeSelectors.biggestSize;
-
-/**
- * Builder for {@link Fotoapparat}.
- */
-public class FotoapparatBuilder {
-
-    Context context;
-    CameraProvider cameraProvider = v1();
-    CameraRenderer renderer;
-
-    SelectorFunction<Collection<LensPosition>, LensPosition> lensPositionSelector = firstAvailable(
-            back(),
-            front(),
-            external()
-    );
-    SelectorFunction<Collection<Size>, Size> photoSizeSelector = biggestSize();
-    SelectorFunction<Collection<Size>, Size> previewSizeSelector = biggestSize();
-    SelectorFunction<Collection<FocusMode>, FocusMode> focusModeSelector = firstAvailable(
-            continuousFocus(),
-            autoFocus(),
-            fixed()
-    );
-    SelectorFunction<Collection<Flash>, Flash> flashSelector = FlashSelectors.off();
-    SelectorFunction<Collection<Range<Integer>>, Range<Integer>> previewFpsRangeSelector = Selectors.nothing();
-    SelectorFunction<Range<Integer>, Integer> sensorSensitivitySelector = Selectors.nothing();
-
-    Integer jpegQuality;
-
-    ScaleType scaleType = ScaleType.CENTER_CROP;
-
-    FrameProcessor frameProcessor = null;
-
-    Logger logger = Loggers.none();
-
-    CameraErrorCallback cameraErrorCallback = CameraErrorCallback.NULL;
-
-    FotoapparatBuilder(@NonNull Context context) {
-        this.context = context;
-    }
-
-    /**
-     * @param cameraProvider decides which {@link CameraDevice} to use.
-     */
-    public FotoapparatBuilder cameraProvider(@NonNull CameraProvider cameraProvider) {
-        this.cameraProvider = cameraProvider;
-        return this;
-    }
-
-    /**
-     * @param selector selects size of the photo (in pixels) from list of available sizes.
-     */
-    public FotoapparatBuilder photoSize(@NonNull SelectorFunction<Collection<Size>, Size> selector) {
-        photoSizeSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param selector selects size of preview stream (in pixels) from list of available sizes.
-     */
-    public FotoapparatBuilder previewSize(@NonNull SelectorFunction<Collection<Size>, Size> selector) {
-        previewSizeSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param scaleType of preview inside the view.
-     */
-    public FotoapparatBuilder previewScaleType(ScaleType scaleType) {
-        this.scaleType = scaleType;
-        return this;
-    }
-
-    /**
-     * @param selector selects focus mode from list of available modes.
-     */
-    public FotoapparatBuilder focusMode(@NonNull SelectorFunction<Collection<FocusMode>, FocusMode> selector) {
-        focusModeSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param selector selects flash mode from list of available modes.
-     */
-    public FotoapparatBuilder flash(@NonNull SelectorFunction<Collection<Flash>, Flash> selector) {
-        flashSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param selector camera sensor position from list of available positions.
-     */
-    public FotoapparatBuilder lensPosition(@NonNull SelectorFunction<Collection<LensPosition>, LensPosition> selector) {
-        lensPositionSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param selector selects preview FPS range from list of available ranges.
-     */
-    public FotoapparatBuilder previewFpsRange(@NonNull SelectorFunction<Collection<Range<Integer>>, Range<Integer>> selector) {
-        previewFpsRangeSelector = selector;
-        return this;
-    }
-
-    /**
-     * @param selector selects ISO value from range of available values.
-     */
-    public FotoapparatBuilder sensorSensitivity(@NonNull SelectorFunction<Range<Integer>, Integer> selector) {
-        sensorSensitivitySelector = selector;
-        return this;
-    }
-
-    /**
-     * @param jpegQuality of the picture (1-100)
-     */
-    public FotoapparatBuilder jpegQuality(@IntRange(from=0,to=100) @NonNull Integer jpegQuality) {
-        this.jpegQuality = jpegQuality;
-        return this;
-    }
-
-    /**
-     * @param frameProcessor receives preview frames for processing.
-     * @see FrameProcessor
-     */
-    public FotoapparatBuilder frameProcessor(@NonNull FrameProcessor frameProcessor) {
-        this.frameProcessor = frameProcessor;
-        return this;
-    }
-
-    /**
-     * @param logger logger which will print logs. No logger is set by default.
-     * @see Loggers
-     */
-    public FotoapparatBuilder logger(@NonNull Logger logger) {
-        this.logger = logger;
-        return this;
-    }
-
-    /**
-     * @param callback which will be notified when camera error happens in Fotoapparat.
-     * @see CameraErrorCallback
-     */
-    public FotoapparatBuilder cameraErrorCallback(@NonNull CameraErrorCallback callback) {
-        this.cameraErrorCallback = callback;
-        return this;
-    }
-
-    /**
-     * @param renderer view which will draw the stream from the camera.
-     * @see CameraView
-     */
-    public FotoapparatBuilder into(@NonNull CameraRenderer renderer) {
-        this.renderer = renderer;
-        return this;
-    }
-
-    /**
-     * @return set up instance of {@link Fotoapparat}.
-     * @throws IllegalStateException if some mandatory parameters are not specified.
-     */
-    public Fotoapparat build() {
-        validate();
-
-        return Fotoapparat.create(this);
-    }
-
-    private void validate() {
-        if (cameraProvider == null) {
-            throw new IllegalStateException("CameraProvider is mandatory.");
-        }
-
-        if (renderer == null) {
-            throw new IllegalStateException("CameraRenderer is mandatory.");
-        }
-
-        if (lensPositionSelector == null) {
-            throw new IllegalStateException("LensPosition selector is mandatory.");
-        }
-
-        if (photoSizeSelector == null) {
-            throw new IllegalStateException("Photo size selector is mandatory.");
-        }
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/FotoapparatBuilder.kt

@@ -0,0 +1,202 @@
+package io.fotoapparat
+
+import android.content.Context
+import io.fotoapparat.configuration.CameraConfiguration
+import io.fotoapparat.error.CameraErrorCallback
+import io.fotoapparat.error.CameraErrorListener
+import io.fotoapparat.log.Logger
+import io.fotoapparat.log.none
+import io.fotoapparat.parameter.ScaleType
+import io.fotoapparat.selector.*
+import io.fotoapparat.util.FrameProcessor
+import io.fotoapparat.view.CameraRenderer
+import io.fotoapparat.view.CameraView
+import io.fotoapparat.view.FocusView
+import io.fotoapparat.preview.FrameProcessor as FrameProcessorJava
+
+/**
+ * Builder for [Fotoapparat].
+ */
+class FotoapparatBuilder internal constructor(private var context: Context) {
+
+    internal var lensPositionSelector: LensPositionSelector = firstAvailable(
+            back(),
+            front(),
+            external()
+    )
+    internal var cameraErrorCallback: CameraErrorCallback = {}
+    internal var renderer: CameraRenderer? = null
+    internal var focusView: FocusView? = null
+    internal var scaleType: ScaleType = ScaleType.CenterCrop
+    internal var logger: Logger = none()
+
+    internal var configuration = CameraConfiguration.default()
+
+    /**
+     * @param selector camera sensor position from list of available positions.
+     */
+    fun lensPosition(selector: LensPositionSelector): FotoapparatBuilder =
+            apply { lensPositionSelector = selector }
+
+    /**
+     * @param scaleType of preview inside the view.
+     */
+    fun previewScaleType(scaleType: ScaleType): FotoapparatBuilder =
+            apply { this.scaleType = scaleType }
+
+    /**
+     * @param selector selects resolution of the photo (in pixels) from list of available resolutions.
+     */
+    fun photoResolution(selector: ResolutionSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                pictureResolution = selector
+        )
+    }
+
+    /**
+     * @param selector selects size of preview stream (in pixels) from list of available resolutions.
+     */
+    fun previewResolution(selector: ResolutionSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                previewResolution = selector
+        )
+    }
+
+
+    /**
+     * @param selector selects focus mode from list of available modes.
+     */
+    fun focusMode(selector: FocusModeSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                focusMode = selector
+        )
+    }
+
+    /**
+     * @param selector selects flash mode from list of available modes.
+     */
+    fun flash(selector: FlashSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                flashMode = selector
+        )
+    }
+
+    /**
+     * @param selector selects preview FPS range from list of available ranges.
+     */
+    fun previewFpsRange(selector: FpsRangeSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                previewFpsRange = selector
+        )
+    }
+
+    /**
+     * @param selector selects ISO value from range of available values.
+     */
+    fun sensorSensitivity(selector: SensorSensitivitySelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                sensorSensitivity = selector
+        )
+    }
+
+    /**
+     * @param selector of the Jpeg picture quality.
+     */
+    fun jpegQuality(selector: QualitySelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                jpegQuality = selector
+        )
+    }
+
+    /**
+     * @param selector selects exposure compensation value from available range.
+     */
+    fun exposureCompensation(selector: ExposureSelector): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                exposureCompensation = selector
+        )
+    }
+
+    /**
+     * @param frameProcessor receives preview frames for processing.
+     * @see FrameProcessorJava
+     */
+    fun frameProcessor(frameProcessor: FrameProcessor): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                frameProcessor = frameProcessor
+        )
+    }
+
+    /**
+     * @param frameProcessor receives preview frames for processing.
+     * @see FrameProcessorJava
+     */
+    fun frameProcessor(frameProcessor: FrameProcessorJava): FotoapparatBuilder = apply {
+        configuration = configuration.copy(
+                frameProcessor = { frameProcessor.process(it) }
+        )
+    }
+
+    /**
+     * @param logger logger which will print logs. No logger is set by default.
+     * @see io.fotoapparat.log.Loggers
+     */
+    fun logger(logger: Logger): FotoapparatBuilder =
+            apply { this.logger = logger }
+
+    /**
+     * @param callback which will be notified when camera error happens in Fotoapparat.
+     * @see CameraErrorListener
+     */
+    fun cameraErrorCallback(callback: CameraErrorListener): FotoapparatBuilder =
+            apply { cameraErrorCallback = { callback.onError(it) } }
+
+    /**
+     * @param callback which will be notified when camera error happens in Fotoapparat.
+     * @see CameraErrorListener
+     */
+    fun cameraErrorCallback(callback: CameraErrorCallback): FotoapparatBuilder =
+            apply { cameraErrorCallback = callback }
+
+    /**
+     * @param renderer view which will draw the stream from the camera.
+     * @see CameraView
+     */
+    fun into(renderer: CameraRenderer): FotoapparatBuilder =
+            apply { this.renderer = renderer }
+
+    /**
+     * @param focusView view which will be used for touch to focus.
+     * @see FocusView
+     */
+    fun focusView(focusView: FocusView): FotoapparatBuilder =
+            apply { this.focusView = focusView }
+
+    /**
+     * @return set up instance of [Fotoapparat].
+     * @throws IllegalStateException if some mandatory parameters are not specified.
+     */
+    fun build() = buildInternal(
+            renderer = renderer
+    )
+
+    private fun buildInternal(
+            renderer: CameraRenderer?
+    ): Fotoapparat {
+        if (renderer == null) {
+            throw IllegalStateException("CameraRenderer is mandatory.")
+        }
+
+        return Fotoapparat(
+                context = context,
+                view = renderer,
+                focusView = focusView,
+                lensPosition = lensPositionSelector,
+                cameraConfiguration = configuration,
+                scaleType = scaleType,
+                cameraErrorCallback = cameraErrorCallback,
+                logger = logger
+        )
+    }
+
+}

fotoapparat/src/main/java/io/fotoapparat/FotoapparatSwitcher.java

@@ -1,77 +0,0 @@
-package io.fotoapparat;
-
-import android.support.annotation.NonNull;
-
-/**
- * Switches between different instances of {@link Fotoapparat}. Convenient when you want to allow
- * user to switch between different cameras or configurations.
- * <p>
- * This class is not thread safe. Consider using it from a single thread.
- */
-public class FotoapparatSwitcher {
-
-    @NonNull
-    private Fotoapparat fotoapparat;
-
-    private boolean started = false;
-
-    private FotoapparatSwitcher(@NonNull Fotoapparat fotoapparat) {
-        this.fotoapparat = fotoapparat;
-    }
-
-    /**
-     * @return {@link FotoapparatSwitcher} with given {@link Fotoapparat} used by default.
-     */
-    public static FotoapparatSwitcher withDefault(@NonNull Fotoapparat fotoapparat) {
-        return new FotoapparatSwitcher(fotoapparat);
-    }
-
-    /**
-     * Starts {@link Fotoapparat} associated with this switcher. Every new {@link Fotoapparat} will
-     * be started automatically until {@link #stop()} is called.
-     *
-     * @throws IllegalStateException if switcher is already started.
-     */
-    public void start() {
-        fotoapparat.start();
-
-        started = true;
-    }
-
-    /**
-     * Stops currently used {@link Fotoapparat}.
-     *
-     * @throws IllegalStateException if switcher is already stopped.
-     */
-    public void stop() {
-        fotoapparat.stop();
-
-        started = false;
-    }
-
-    /**
-     * Switches to another {@link Fotoapparat}. If switcher is already started then previously used
-     * {@link Fotoapparat} will be stopped automatically and new {@link Fotoapparat} will be
-     * started.
-     *
-     * @param fotoapparat new {@link Fotoapparat} to use.
-     * @throws NullPointerException if given {@link Fotoapparat} is {@code null}.
-     */
-    public void switchTo(@NonNull Fotoapparat fotoapparat) {
-        if (started) {
-            this.fotoapparat.stop();
-            fotoapparat.start();
-        }
-
-        this.fotoapparat = fotoapparat;
-    }
-
-    /**
-     * @return currently used instance of {@link Fotoapparat}.
-     */
-    @NonNull
-    public Fotoapparat getCurrentFotoapparat() {
-        return fotoapparat;
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/capability/Capabilities.kt

@@ -0,0 +1,59 @@
+package io.fotoapparat.capability
+
+import io.fotoapparat.parameter.*
+import io.fotoapparat.util.lineSeparator
+import io.fotoapparat.util.wrap
+
+/**
+ * Capabilities of camera hardware.
+ *
+ * Sensor sensitivities is not guaranteed to always contain a value.
+ */
+data class Capabilities(
+        val zoom: Zoom,
+        val flashModes: Set<Flash>,
+        val focusModes: Set<FocusMode>,
+        val canSmoothZoom: Boolean,
+        val maxFocusAreas: Int,
+        val maxMeteringAreas: Int,
+        val jpegQualityRange: IntRange,
+        val exposureCompensationRange: IntRange,
+        val previewFpsRanges: Set<FpsRange>,
+        val antiBandingModes: Set<AntiBandingMode>,
+        val pictureResolutions: Set<Resolution>,
+        val previewResolutions: Set<Resolution>,
+        val sensorSensitivities: Set<Int>
+) {
+
+    init {
+        flashModes.ensureNotEmpty()
+        focusModes.ensureNotEmpty()
+        antiBandingModes.ensureNotEmpty()
+        previewFpsRanges.ensureNotEmpty()
+        pictureResolutions.ensureNotEmpty()
+        previewResolutions.ensureNotEmpty()
+    }
+
+    override fun toString(): String {
+        return "Capabilities" + lineSeparator +
+                "zoom:" + zoom.wrap() +
+                "flashModes:" + flashModes.wrap() +
+                "focusModes:" + focusModes.wrap() +
+                "canSmoothZoom:" + canSmoothZoom.wrap() +
+                "maxFocusAreas:" + maxFocusAreas.wrap() +
+                "maxMeteringAreas:" + maxMeteringAreas.wrap() +
+                "jpegQualityRange:" + jpegQualityRange.wrap() +
+                "exposureCompensationRange:" + exposureCompensationRange.wrap() +
+                "antiBandingModes:" + antiBandingModes.wrap() +
+                "previewFpsRanges:" + previewFpsRanges.wrap() +
+                "pictureResolutions:" + pictureResolutions.wrap() +
+                "previewResolutions:" + previewResolutions.wrap() +
+                "sensorSensitivities:" + sensorSensitivities.wrap()
+    }
+}
+
+private inline fun <reified E> Set<E>.ensureNotEmpty() {
+    if (isEmpty()) {
+        throw IllegalArgumentException("Capabilities cannot have an empty Set<${E::class.java.simpleName}>.")
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/capability/provide/CapabilitiesProvider.kt

@@ -0,0 +1,35 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.capability.provide
+
+import android.hardware.Camera
+import io.fotoapparat.capability.Capabilities
+import io.fotoapparat.parameter.SupportedParameters
+import io.fotoapparat.parameter.camera.convert.*
+
+/**
+ * Returns the [io.fotoapparat.capability.Capabilities] of the given [Camera].
+ */
+internal fun Camera.getCapabilities() = SupportedParameters(parameters).getCapabilities()
+
+private fun SupportedParameters.getCapabilities(): Capabilities {
+    return Capabilities(
+            zoom = supportedZoom,
+            flashModes = flashModes.extract { it.toFlash() },
+            focusModes = focusModes.extract { it.toFocusMode() },
+            maxFocusAreas = maxNumFocusAreas,
+            canSmoothZoom = supportedSmoothZoom,
+            maxMeteringAreas = maxNumMeteringAreas,
+            jpegQualityRange = jpegQualityRange,
+            exposureCompensationRange = exposureCompensationRange,
+            antiBandingModes = supportedAutoBandingModes.extract(String::toAntiBandingMode),
+            sensorSensitivities = sensorSensitivities.toSet(),
+            previewFpsRanges = supportedPreviewFpsRanges.extract { it.toFpsRange() },
+            pictureResolutions = pictureResolutions.mapSizes(),
+            previewResolutions = previewResolutions.mapSizes()
+    )
+}
+
+private fun <Parameter : Any, Code> List<Code>.extract(converter: (Code) -> Parameter?) = mapNotNull { converter(it) }.toSet()
+
+private fun Collection<Camera.Size>.mapSizes() = map { it.toResolution() }.toSet()

fotoapparat/src/main/java/io/fotoapparat/characteristic/CameraInfoProvider.kt

@@ -0,0 +1,21 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.characteristic
+
+import android.hardware.Camera
+import io.fotoapparat.hardware.orientation.toOrientation
+
+/**
+ * Returns the [Characteristics] for the given `cameraId`.
+ */
+internal fun getCharacteristics(cameraId: Int): Characteristics {
+    val info = Camera.CameraInfo()
+    Camera.getCameraInfo(cameraId, info)
+    val lensPosition = info.facing.toLensPosition()
+    return Characteristics(
+            cameraId = cameraId,
+            lensPosition = lensPosition,
+            cameraOrientation = info.orientation.toOrientation(),
+            isMirrored = lensPosition == LensPosition.Front
+    )
+}

fotoapparat/src/main/java/io/fotoapparat/characteristic/Characteristic.kt

@@ -0,0 +1,6 @@
+package io.fotoapparat.characteristic
+
+/**
+ * A camera characteristic.
+ */
+interface Characteristic

fotoapparat/src/main/java/io/fotoapparat/characteristic/Characteristics.kt

@@ -0,0 +1,13 @@
+package io.fotoapparat.characteristic
+
+import io.fotoapparat.hardware.orientation.Orientation
+
+/**
+ * A set of information about the camera.
+ */
+internal data class Characteristics(
+        val cameraId: Int,
+        val lensPosition: LensPosition,
+        val cameraOrientation: Orientation,
+        val isMirrored: Boolean
+)

fotoapparat/src/main/java/io/fotoapparat/characteristic/LensPosition.kt

@@ -1,23 +1,23 @@
-package io.fotoapparat.parameter;
+package io.fotoapparat.characteristic
 
 /**
  * The camera position relatively to the screen of the device.
  */
-public enum LensPosition {
+sealed class LensPosition : Characteristic {
 
     /**
      * The back camera.
      */
-    BACK,
+    object Back : LensPosition()
 
     /**
      * The front camera.
      */
-    FRONT,
+    object Front : LensPosition()
 
     /**
      * An external camera.
      */
-    EXTERNAL
+    object External : LensPosition()
 
-}
+}

fotoapparat/src/main/java/io/fotoapparat/characteristic/LensPositionCharacteristic.kt

@@ -0,0 +1,39 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.characteristic
+
+import android.hardware.Camera
+import io.fotoapparat.exception.camera.CameraException
+
+/**
+ * On some devices with double cameras v1 still returns external lens position (as in v2).
+ */
+private const val CAMERA_FACING_EXTERNAL = 2
+
+/**
+ * Maps between [LensPosition] and Camera v1 lens position code id.
+ *
+ * @receiver Camera facing info id.
+ * @return [LensPosition] from the given lens position code id.
+ * `null` if position code id is not supported.
+ */
+internal fun Int.toLensPosition(): LensPosition =
+        when (this) {
+            Camera.CameraInfo.CAMERA_FACING_FRONT -> LensPosition.Front
+            Camera.CameraInfo.CAMERA_FACING_BACK -> LensPosition.Back
+            CAMERA_FACING_EXTERNAL -> LensPosition.External
+            else -> throw IllegalArgumentException("Lens position $this is not supported.")
+        }
+
+/**
+ * Maps between [LensPosition] and Camera v1 code id.
+ *
+ * @receiver [LensPosition]
+ * @return code of the camera as in [Camera.CameraInfo].
+ */
+fun LensPosition.toCameraId(): Int =
+        (0 until Camera.getNumberOfCameras())
+                .find { cameraId ->
+                    this == getCharacteristics(cameraId).lensPosition
+                }
+                ?: throw CameraException("Device has no camera for the desired lens position(s).")

fotoapparat/src/main/java/io/fotoapparat/concurrent/CameraExecutor.kt

@@ -0,0 +1,78 @@
+package io.fotoapparat.concurrent
+
+import java.util.*
+import java.util.concurrent.Callable
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+
+/**
+ * Executes camera related operations using a dedicated thread and provides a control over the queue
+ * of those operations.
+ *
+ * This class should be accessed only from a one thread at a time.
+ */
+class CameraExecutor(
+        private val executor: ExecutorService = Executors.newSingleThreadExecutor()
+) {
+
+    private val cancellableTasksQueue = LinkedList<Future<*>>()
+
+    /**
+     * Adds operation to the serial execution queue.
+     */
+    fun <T> execute(operation: Operation<T>): Future<T> {
+        val future = executor.submit(Callable {
+            operation.function()
+        })
+
+        if (operation.cancellable) {
+            cancellableTasksQueue += future
+        }
+
+        cleanUpCancelledTasks()
+
+        return future
+    }
+
+    private fun cleanUpCancelledTasks() {
+        cancellableTasksQueue.removeAll {
+            !it.isPending
+        }
+    }
+
+    /**
+     * Cancels all cancellable tasks in the queue. Non-cancellable tasks would still be executed.
+     *
+     * After this operation is completed the executor is still in a valid state and can be used
+     * further.
+     */
+    fun cancelTasks() {
+        cancellableTasksQueue
+                .filter { it.isPending }
+                .forEach {
+                    it.cancel(true)
+                }
+        cancellableTasksQueue.clear()
+    }
+
+    private val Future<*>.isPending get() = !isCancelled && !isDone
+
+    /**
+     * Operation to be executed.
+     */
+    data class Operation<out T>(
+
+            /**
+             * `true` if operation could be cancelled. `false` if operation can not be cancelled.
+             */
+            val cancellable: Boolean = false,
+
+            /**
+             * Body of the operation.
+             */
+            val function: () -> T
+
+    )
+
+}

fotoapparat/src/main/java/io/fotoapparat/configuration/CameraConfiguration.kt

@@ -0,0 +1,131 @@
+package io.fotoapparat.configuration
+
+import io.fotoapparat.selector.*
+import io.fotoapparat.util.FrameProcessor
+import io.fotoapparat.preview.FrameProcessor as FrameProcessorJava
+
+
+private const val DEFAULT_JPEG_QUALITY = 90
+private const val DEFAULT_EXPOSURE_COMPENSATION = 0
+
+/**
+ * A camera configuration which has all it's selectors defined.
+ */
+data class CameraConfiguration(
+        override val flashMode: FlashSelector = off(),
+        override val focusMode: FocusModeSelector = firstAvailable(
+                continuousFocusPicture(),
+                autoFocus(),
+                fixed(),
+                infinity()
+        ),
+        override val jpegQuality: QualitySelector = manualJpegQuality(DEFAULT_JPEG_QUALITY),
+        override val exposureCompensation: ExposureSelector = manualExposure(DEFAULT_EXPOSURE_COMPENSATION),
+        override val frameProcessor: FrameProcessor = {},
+        override val previewFpsRange: FpsRangeSelector = highestFps(),
+        override val antiBandingMode: AntiBandingModeSelector = firstAvailable(
+                auto(),
+                hz50(),
+                hz60(),
+                none()
+        ),
+        override val sensorSensitivity: SensorSensitivitySelector? = null,
+        override val pictureResolution: ResolutionSelector = highestResolution(),
+        override val previewResolution: ResolutionSelector = highestResolution()
+) : Configuration {
+
+    /**
+     * Builder for [CameraConfiguration].
+     */
+    class Builder internal constructor() {
+
+        private var cameraConfiguration: CameraConfiguration = default()
+
+        fun flash(selector: FlashSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    flashMode = selector
+            )
+        }
+
+        fun focusMode(selector: FocusModeSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    focusMode = selector
+            )
+        }
+
+        fun previewFpsRange(selector: FpsRangeSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    previewFpsRange = selector
+            )
+        }
+
+        fun exposureCompensation(selector: ExposureSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    exposureCompensation = selector
+            )
+        }
+
+        fun antiBandingMode(selector: AntiBandingModeSelector): Builder = apply {
+            cameraConfiguration.copy(
+                    antiBandingMode = selector
+            )
+        }
+
+        fun jpegQuality(selector: QualitySelector): Builder = apply {
+            cameraConfiguration.copy(
+                    jpegQuality = selector
+            )
+        }
+
+        fun sensorSensitivity(selector: SensorSensitivitySelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    sensorSensitivity = selector
+            )
+        }
+
+        fun previewResolution(selector: ResolutionSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    previewResolution = selector
+            )
+        }
+
+        fun photoResolution(selector: ResolutionSelector): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    pictureResolution = selector
+            )
+        }
+
+        fun frameProcessor(frameProcessor: FrameProcessorJava): Builder = apply {
+            cameraConfiguration = cameraConfiguration.copy(
+                    frameProcessor = frameProcessor::process
+            )
+        }
+
+        /**
+         * Builds a new [CameraConfiguration].
+         */
+        fun build(): CameraConfiguration = cameraConfiguration
+    }
+
+
+    companion object {
+
+        /**
+         * Alias for [CameraConfiguration.default]
+         */
+        @JvmStatic
+        fun standard(): CameraConfiguration = default()
+
+        /**
+         * Default [CameraConfiguration].
+         */
+        @JvmStatic
+        fun default(): CameraConfiguration = CameraConfiguration()
+
+        /**
+         * Creates a new [CameraConfiguration.Builder].
+         */
+        @JvmStatic
+        fun builder(): Builder = Builder()
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/configuration/Configuration.kt

@@ -0,0 +1,17 @@
+package io.fotoapparat.configuration
+
+import io.fotoapparat.selector.*
+import io.fotoapparat.util.FrameProcessor
+
+interface Configuration {
+    val flashMode: FlashSelector?
+    val focusMode: FocusModeSelector?
+    val jpegQuality: QualitySelector?
+    val exposureCompensation: ExposureSelector?
+    val frameProcessor: FrameProcessor?
+    val previewFpsRange: FpsRangeSelector?
+    val antiBandingMode: AntiBandingModeSelector?
+    val sensorSensitivity: SensorSensitivitySelector?
+    val previewResolution: ResolutionSelector?
+    val pictureResolution: ResolutionSelector?
+}

fotoapparat/src/main/java/io/fotoapparat/configuration/UpdateConfiguration.kt

@@ -0,0 +1,103 @@
+package io.fotoapparat.configuration
+
+import io.fotoapparat.selector.*
+import io.fotoapparat.util.FrameProcessor
+
+/**
+ * A camera update configuration.
+ */
+data class UpdateConfiguration(
+        override val flashMode: FlashSelector? = null,
+        override val focusMode: FocusModeSelector? = null,
+        override val jpegQuality: QualitySelector? = null,
+        override val exposureCompensation: ExposureSelector? = null,
+        override val frameProcessor: FrameProcessor? = null,
+        override val previewFpsRange: FpsRangeSelector? = null,
+        override val antiBandingMode: AntiBandingModeSelector? = null,
+        override val sensorSensitivity: SensorSensitivitySelector? = null,
+        override val previewResolution: ResolutionSelector? = null,
+        override val pictureResolution: ResolutionSelector? = null
+) : Configuration {
+
+    /**
+     * Builder for [UpdateConfiguration].
+     */
+    class Builder internal constructor() {
+
+        private var configuration = UpdateConfiguration()
+
+        fun flash(selector: FlashSelector): Builder = apply {
+            configuration = configuration.copy(
+                    flashMode = selector
+            )
+        }
+
+        fun focusMode(selector: FocusModeSelector): Builder = apply {
+            configuration = configuration.copy(
+                    focusMode = selector
+            )
+        }
+
+        fun previewFpsRange(selector: FpsRangeSelector): Builder = apply {
+            configuration = configuration.copy(
+                    previewFpsRange = selector
+            )
+        }
+
+        fun sensorSensitivity(selector: SensorSensitivitySelector): Builder = apply {
+            configuration = configuration.copy(
+                    sensorSensitivity = selector
+            )
+        }
+
+        fun antiBandingMode(selector: AntiBandingModeSelector): Builder = apply {
+            configuration = configuration.copy(
+                    antiBandingMode = selector
+            )
+        }
+
+        fun jpegQuality(selector: QualitySelector): Builder = apply {
+            configuration = configuration.copy(
+                    jpegQuality = selector
+            )
+        }
+
+        fun exposureCompensation(selector: ExposureSelector): Builder = apply {
+            configuration = configuration.copy(
+                    exposureCompensation = selector
+            )
+        }
+
+        fun previewResolution(selector: ResolutionSelector): Builder = apply {
+            configuration = configuration.copy(
+                    previewResolution = selector
+            )
+        }
+
+        fun photoResolution(selector: ResolutionSelector): Builder = apply {
+            configuration = configuration.copy(
+                    pictureResolution = selector
+            )
+        }
+
+        fun frameProcessor(frameProcessor: FrameProcessor): Builder = apply {
+            configuration = configuration.copy(
+                    frameProcessor = frameProcessor
+            )
+        }
+
+        /**
+         * Builds a new [UpdateConfiguration].
+         */
+        fun build(): UpdateConfiguration = configuration
+    }
+
+    companion object {
+
+        /**
+         * Creates a new [UpdateConfiguration.Builder].
+         */
+        @JvmStatic
+        fun builder(): Builder = Builder()
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/coroutines/AwaitBroadcastChannel.kt

@@ -0,0 +1,33 @@
+package io.fotoapparat.coroutines
+
+import kotlinx.coroutines.experimental.CompletableDeferred
+import kotlinx.coroutines.experimental.Deferred
+import kotlinx.coroutines.experimental.channels.BroadcastChannel
+import kotlinx.coroutines.experimental.channels.ConflatedBroadcastChannel
+
+/**
+ * A [ConflatedBroadcastChannel] which exposes a [getValue] which will [await] for at least one value.
+ */
+internal class AwaitBroadcastChannel<T>(
+        private val channel: ConflatedBroadcastChannel<T> = ConflatedBroadcastChannel(),
+        private val deferred: CompletableDeferred<Boolean> = CompletableDeferred()
+) : BroadcastChannel<T> by channel, Deferred<Boolean> by deferred {
+
+    /**
+     * The most recently sent element to this channel.
+     */
+    suspend fun getValue(): T {
+        deferred.await()
+        return channel.value
+    }
+
+    override fun offer(element: T): Boolean {
+        deferred.complete(true)
+        return channel.offer(element)
+    }
+
+    override suspend fun send(element: T) {
+        deferred.complete(true)
+        channel.send(element)
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/error/Callbacks.java

@@ -1,36 +0,0 @@
-package io.fotoapparat.error;
-
-import android.os.Handler;
-import android.os.Looper;
-
-import io.fotoapparat.hardware.CameraException;
-
-/**
- * Factory methods for callbacks.
- */
-public class Callbacks {
-
-    private static final Handler MAIN_THREAD_HANDLER = new Handler(Looper.getMainLooper());
-
-    /**
-     * @return CameraErrorCallback which will always move execution to the main thread.
-     */
-    public static CameraErrorCallback onMainThread(final CameraErrorCallback original) {
-        return new CameraErrorCallback() {
-            @Override
-            public void onError(final CameraException e) {
-                if (Looper.myLooper() == Looper.getMainLooper()) {
-                    original.onError(e);
-                } else {
-                    MAIN_THREAD_HANDLER.post(new Runnable() {
-                        @Override
-                        public void run() {
-                            original.onError(e);
-                        }
-                    });
-                }
-            }
-        };
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/error/CameraErrorCallback.java

@@ -1,27 +0,0 @@
-package io.fotoapparat.error;
-
-import io.fotoapparat.hardware.CameraException;
-
-/**
- * Notified when an camera error happens within Fotoapparat.
- * <p>
- * This method is always called from the main thread.
- */
-public interface CameraErrorCallback {
-
-    /**
-     * No-op implementation of {@link CameraErrorCallback}.
-     */
-    CameraErrorCallback NULL = new CameraErrorCallback() {
-        @Override
-        public void onError(CameraException e) {
-            // Do nothing
-        }
-    };
-
-    /**
-     * Notified when a camera error happens within Fotoapparat.
-     */
-    void onError(CameraException e);
-
-}

fotoapparat/src/main/java/io/fotoapparat/error/CameraErrorCallback.kt

@@ -0,0 +1,16 @@
+package io.fotoapparat.error
+
+import io.fotoapparat.exception.camera.CameraException
+
+/**
+ * Notified when an camera error happens within Fotoapparat.
+ *
+ * This method is always called from the main thread.
+ */
+interface CameraErrorListener {
+
+    /**
+     * Notified when a camera error happens within Fotoapparat.
+     */
+    fun onError(e: CameraException)
+}

fotoapparat/src/main/java/io/fotoapparat/error/ErrorCallbacks.kt

@@ -0,0 +1,19 @@
+package io.fotoapparat.error
+
+import android.os.Looper
+import io.fotoapparat.exception.camera.CameraException
+import io.fotoapparat.hardware.executeMainThread
+
+
+typealias CameraErrorCallback = (CameraException) -> Unit
+
+/**
+ * @return CameraErrorCallback which will always move execution to the main thread.
+ */
+fun CameraErrorCallback.onMainThread(): CameraErrorCallback = { cameraException ->
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+        this(cameraException)
+    } else {
+        executeMainThread { this(cameraException) }
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/exception/FileSaveException.kt

@@ -0,0 +1,6 @@
+package io.fotoapparat.exception
+
+/**
+ * Thrown when there is a problem while saving the file.
+ */
+class FileSaveException(cause: Throwable) : RuntimeException(cause)

fotoapparat/src/main/java/io/fotoapparat/exception/LevelOutOfRangeException.kt

@@ -0,0 +1,6 @@
+package io.fotoapparat.exception
+
+/**
+ * Thrown when zoom level is outside of [0..1] range.
+ */
+class LevelOutOfRangeException(zoomLevel: Float) : RuntimeException(zoomLevel.toString() + " is out of range [0..1]")

fotoapparat/src/main/java/io/fotoapparat/exception/RecoverableRuntimeException.kt

@@ -0,0 +1,11 @@
+package io.fotoapparat.exception
+
+/**
+ * Exception which is not caused by developer and can be either ignored or recovered from.
+ */
+open class RecoverableRuntimeException : RuntimeException {
+
+    constructor(message: String) : super(message)
+
+    constructor(throwable: Throwable) : super(throwable)
+}

fotoapparat/src/main/java/io/fotoapparat/exception/UnableToDecodeBitmapException.kt

@@ -0,0 +1,6 @@
+package io.fotoapparat.exception
+
+/**
+ * Thrown when it is not possible to decode bitmap from byte array.
+ */
+class UnableToDecodeBitmapException : RecoverableRuntimeException("Unable to decode bitmap")

fotoapparat/src/main/java/io/fotoapparat/exception/camera/CameraException.kt

@@ -0,0 +1,12 @@
+package io.fotoapparat.exception.camera
+
+/**
+ * A generic camera exception.
+ */
+open class CameraException(
+        message: String,
+        cause: Throwable? = null
+) : RuntimeException(
+        message,
+        cause
+)

fotoapparat/src/main/java/io/fotoapparat/exception/camera/InvalidConfigurationException.kt

@@ -0,0 +1,30 @@
+package io.fotoapparat.exception.camera
+
+import io.fotoapparat.parameter.Parameter
+
+/**
+ * Thrown to indicate that a selected [Parameter] is not in the supported set.
+ *
+ * e.g. Camera supports flash `on`, `off` & `auto` and you ask for a `tomato`.
+ */
+internal class InvalidConfigurationException : CameraException {
+    constructor(
+            value: Any,
+            klass: Class<out Parameter>,
+            supportedParameters: Collection<Parameter>
+    ) : super(
+            "${klass.simpleName} configuration selector selected value $value. " +
+                    "However it's not in the supported set of values. " +
+                    "Supported parameters: $supportedParameters"
+    )
+
+    constructor(
+            value: Any,
+            klass: Class<out Comparable<*>>,
+            supportedRange: ClosedRange<*>
+    ) : super(
+            "${klass.simpleName} configuration selector selected value $value. " +
+                    "However it's not in the supported set of values. " +
+                    "Supported parameters from: ${supportedRange.start} to ${supportedRange.endInclusive}."
+    )
+}

fotoapparat/src/main/java/io/fotoapparat/exception/camera/UnavailableSurfaceException.kt

@@ -0,0 +1,9 @@
+package io.fotoapparat.exception.camera
+
+/**
+ * Thrown when the preview surface didn't become available.
+ */
+class UnavailableSurfaceException : CameraException(
+        "No preview surface became available before CameraView got detached from window. " +
+                "Camera didn't start. You may ignore this exception."
+)

fotoapparat/src/main/java/io/fotoapparat/exception/camera/UnsupportedConfigurationException.kt

@@ -0,0 +1,25 @@
+package io.fotoapparat.exception.camera
+
+import io.fotoapparat.parameter.Parameter
+
+/**
+ * Thrown to indicate that a configuration selector couldn't select a value.
+ */
+internal class UnsupportedConfigurationException : CameraException {
+    constructor(
+            klass: Class<out Parameter>,
+            supportedParameters: Collection<Parameter>
+    ) : super(
+            "${klass.simpleName} configuration selector couldn't select a value. " +
+                    "Supported parameters: $supportedParameters"
+    )
+
+    constructor(
+            configurationName: String,
+            supportedRange: ClosedRange<*>
+    ) : super(
+            "$configurationName configuration selector couldn't select a value. " +
+                    "Supported parameters from: ${supportedRange.start} to ${supportedRange.endInclusive}."
+    )
+
+}

fotoapparat/src/main/java/io/fotoapparat/exception/camera/UnsupportedLensException.kt

@@ -0,0 +1,6 @@
+package io.fotoapparat.exception.camera
+
+/**
+ * Thrown to indicate that the device has no camera for the desired lens position(s).
+ */
+class UnsupportedLensException : CameraException("Device has no camera for the desired lens position(s).")

fotoapparat/src/main/java/io/fotoapparat/exif/ExifOrientationWriter.kt

@@ -0,0 +1,18 @@
+package io.fotoapparat.exif
+
+import java.io.File
+
+/**
+ * Writes Exif orientation attributes.
+ */
+internal interface ExifOrientationWriter {
+
+    /**
+     * Writes EXIF orientation tag into a file, overwriting it if it already exists.
+     *
+     * @param file     File of the image.
+     * @param photo    Photo stored in the file.
+     * @throws FileSaveException If writing has failed.
+     */
+    fun writeExifOrientation(file: File, rotationDegrees: Int)
+}

fotoapparat/src/main/java/io/fotoapparat/exif/ExifWriter.kt

@@ -0,0 +1,39 @@
+package io.fotoapparat.exif
+
+import android.media.ExifInterface
+import io.fotoapparat.exception.FileSaveException
+import java.io.File
+import java.io.IOException
+
+/**
+ * Writes Exif attributes.
+ */
+internal object ExifWriter : ExifOrientationWriter {
+
+    @Throws(FileSaveException::class)
+    override fun writeExifOrientation(file: File, rotationDegrees: Int) {
+        try {
+            ExifInterface(file.path).apply {
+                setAttribute(
+                        ExifInterface.TAG_ORIENTATION,
+                        toExifOrientation(rotationDegrees).toString()
+                )
+                saveAttributes()
+            }
+        } catch (e: IOException) {
+            throw FileSaveException(e)
+        }
+    }
+
+    private fun toExifOrientation(rotationDegrees: Int): Int {
+        val compensationRotationDegrees = (360 - rotationDegrees) % 360
+
+        return when (compensationRotationDegrees) {
+            90 -> ExifInterface.ORIENTATION_ROTATE_90
+            180 -> ExifInterface.ORIENTATION_ROTATE_180
+            270 -> ExifInterface.ORIENTATION_ROTATE_270
+            else -> ExifInterface.ORIENTATION_NORMAL
+        }
+    }
+}
+

fotoapparat/src/main/java/io/fotoapparat/hardware/CameraDevice.java

@@ -1,83 +0,0 @@
-package io.fotoapparat.hardware;
-
-import android.support.annotation.FloatRange;
-
-import java.util.List;
-
-import io.fotoapparat.hardware.operators.AutoFocusOperator;
-import io.fotoapparat.hardware.operators.CapabilitiesOperator;
-import io.fotoapparat.hardware.operators.CaptureOperator;
-import io.fotoapparat.hardware.operators.ConnectionOperator;
-import io.fotoapparat.hardware.operators.ExposureMeasurementOperator;
-import io.fotoapparat.hardware.operators.OrientationOperator;
-import io.fotoapparat.hardware.operators.ParametersOperator;
-import io.fotoapparat.hardware.operators.PreviewOperator;
-import io.fotoapparat.hardware.operators.PreviewStreamOperator;
-import io.fotoapparat.hardware.operators.RendererParametersOperator;
-import io.fotoapparat.hardware.operators.SurfaceOperator;
-import io.fotoapparat.hardware.operators.ZoomOperator;
-import io.fotoapparat.hardware.provider.AvailableLensPositionsProvider;
-import io.fotoapparat.lens.FocusResult;
-import io.fotoapparat.parameter.LensPosition;
-import io.fotoapparat.parameter.Parameters;
-import io.fotoapparat.parameter.RendererParameters;
-import io.fotoapparat.photo.Photo;
-import io.fotoapparat.preview.PreviewStream;
-
-/**
- * Abstraction for camera hardware.
- */
-public interface CameraDevice extends CaptureOperator,
-        PreviewOperator, CapabilitiesOperator, OrientationOperator, ParametersOperator,
-        ConnectionOperator, SurfaceOperator, PreviewStreamOperator, RendererParametersOperator,
-        ExposureMeasurementOperator, AutoFocusOperator, AvailableLensPositionsProvider,
-        ZoomOperator {
-
-    @Override
-    void open(LensPosition lensPosition);
-
-    @Override
-    void close();
-
-    @Override
-    void startPreview();
-
-    @Override
-    void stopPreview();
-
-    @Override
-    void setDisplaySurface(Object displaySurface);
-
-    @Override
-    void setDisplayOrientation(int degrees);
-
-    @Override
-    void updateParameters(Parameters parameters);
-
-    @Override
-    Capabilities getCapabilities();
-
-    @Override
-    FocusResult autoFocus();
-
-    @Override
-    void measureExposure();
-
-    @Override
-    Photo takePicture();
-
-    @Override
-    PreviewStream getPreviewStream();
-
-    @Override
-    RendererParameters getRendererParameters();
-
-    @Override
-    List<LensPosition> getAvailableLensPositions();
-
-    @Override
-    void setZoom(@FloatRange(from = 0f, to = 1f) float level);
-
-    Parameters getCurrentParameters();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/CameraDevice.kt

@@ -0,0 +1,423 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.hardware
+
+import android.hardware.Camera
+import android.media.MediaRecorder
+import android.support.annotation.FloatRange
+import android.view.Surface
+import io.fotoapparat.capability.Capabilities
+import io.fotoapparat.capability.provide.getCapabilities
+import io.fotoapparat.characteristic.Characteristics
+import io.fotoapparat.characteristic.toCameraId
+import io.fotoapparat.coroutines.AwaitBroadcastChannel
+import io.fotoapparat.exception.camera.CameraException
+import io.fotoapparat.hardware.metering.FocalRequest
+import io.fotoapparat.hardware.metering.convert.toFocusAreas
+import io.fotoapparat.hardware.orientation.*
+import io.fotoapparat.hardware.orientation.Orientation.Vertical.Portrait
+import io.fotoapparat.log.Logger
+import io.fotoapparat.parameter.FocusMode
+import io.fotoapparat.parameter.Resolution
+import io.fotoapparat.parameter.camera.CameraParameters
+import io.fotoapparat.parameter.camera.apply.applyInto
+import io.fotoapparat.parameter.camera.convert.toCode
+import io.fotoapparat.preview.PreviewStream
+import io.fotoapparat.result.FocusResult
+import io.fotoapparat.result.Photo
+import io.fotoapparat.util.FrameProcessor
+import io.fotoapparat.util.lineSeparator
+import io.fotoapparat.view.Preview
+import kotlinx.coroutines.experimental.CompletableDeferred
+import java.io.IOException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+
+typealias PreviewSize = io.fotoapparat.parameter.Resolution
+
+/**
+ * Camera.
+ */
+internal open class CameraDevice(
+        private val logger: Logger,
+        val characteristics: Characteristics
+) {
+
+    private val capabilities = CompletableDeferred<Capabilities>()
+    private val cameraParameters = AwaitBroadcastChannel<CameraParameters>()
+    private lateinit var previewStream: PreviewStream
+    private lateinit var surface: Surface
+    private lateinit var camera: Camera
+
+    private var cachedCameraParameters: Camera.Parameters? = null
+    private var displayOrientation: Orientation = Portrait
+    private var imageOrientation: Orientation = Portrait
+    private var previewOrientation: Orientation = Portrait
+
+    /**
+     * Opens a connection to a camera.
+     */
+    open fun open() {
+        logger.recordMethod()
+
+        val lensPosition = characteristics.lensPosition
+        val cameraId = lensPosition.toCameraId()
+
+        try {
+            camera = Camera.open(cameraId)
+            capabilities.complete(camera.getCapabilities())
+            previewStream = PreviewStream(camera)
+        } catch (e: RuntimeException) {
+            throw CameraException(
+                    message = "Failed to open camera with lens position: $lensPosition and id: $cameraId",
+                    cause = e
+            )
+        }
+    }
+
+    /**
+     * Closes the connection to a camera.
+     */
+    open fun close() {
+        logger.recordMethod()
+        surface.release()
+        camera.release()
+    }
+
+    /**
+     * Starts preview.
+     */
+    open fun startPreview() {
+        logger.recordMethod()
+
+        try {
+            camera.startPreview()
+        } catch (e: RuntimeException) {
+            throw CameraException(
+                    message = "Failed to start preview for camera with lens " +
+                            "position: ${characteristics.lensPosition} and id: ${characteristics.cameraId}",
+                    cause = e
+            )
+        }
+    }
+
+    /**
+     * Stops preview.
+     */
+    open fun stopPreview() {
+        logger.recordMethod()
+
+        camera.stopPreview()
+    }
+
+    /**
+     * Unlock camera.
+     */
+    open fun unlock() {
+        logger.recordMethod()
+
+        camera.unlock()
+    }
+
+    /**
+     * Lock camera.
+     */
+    open fun lock() {
+        logger.recordMethod()
+
+        camera.lock()
+    }
+
+    /**
+     * Invokes a still photo capture action.
+     *
+     * @return The captured photo.
+     */
+    open fun takePhoto(): Photo {
+        logger.recordMethod()
+
+        return camera.takePhoto(imageOrientation.degrees)
+    }
+
+    /**
+     * Returns the [Capabilities] of the camera.
+     */
+    open suspend fun getCapabilities(): Capabilities {
+        logger.recordMethod()
+
+        return capabilities.await()
+    }
+
+    /**
+     * Returns the [CameraParameters] used.
+     */
+    open suspend fun getParameters(): CameraParameters {
+        logger.recordMethod()
+
+        return cameraParameters.getValue()
+    }
+
+    /**
+     * Updates the desired camera parameters.
+     */
+    open suspend fun updateParameters(cameraParameters: CameraParameters) {
+        logger.recordMethod()
+
+        this.cameraParameters.send(cameraParameters)
+
+        logger.log("New camera parameters are: $cameraParameters")
+
+        cameraParameters.applyInto(cachedCameraParameters ?: camera.parameters)
+                .cacheLocally()
+                .setInCamera()
+    }
+
+    /**
+     * Updates the frame processor.
+     */
+    open fun updateFrameProcessor(frameProcessor: FrameProcessor?) {
+        logger.recordMethod()
+
+        previewStream.updateProcessorSafely(frameProcessor)
+    }
+
+    /**
+     * Sets the current orientation of the display.
+     */
+    open fun setDisplayOrientation(orientationState: OrientationState) {
+        logger.recordMethod()
+
+        imageOrientation = computeImageOrientation(
+                deviceOrientation = orientationState.deviceOrientation,
+                cameraOrientation = characteristics.cameraOrientation,
+                cameraIsMirrored = characteristics.isMirrored
+        )
+
+        displayOrientation = computeDisplayOrientation(
+                screenOrientation = orientationState.screenOrientation,
+                cameraOrientation = characteristics.cameraOrientation,
+                cameraIsMirrored = characteristics.isMirrored
+        )
+
+        previewOrientation = computePreviewOrientation(
+                screenOrientation = orientationState.screenOrientation,
+                cameraOrientation = characteristics.cameraOrientation,
+                cameraIsMirrored = characteristics.isMirrored
+        )
+
+        logger.log("Image orientation is: $imageOrientation. " + lineSeparator +
+                "Display orientation is: $displayOrientation. " + lineSeparator +
+                "Preview orientation is: $previewOrientation."
+        )
+
+        previewStream.frameOrientation = previewOrientation
+        camera.setDisplayOrientation(displayOrientation.degrees)
+    }
+
+    /**
+     * Changes zoom level of the camera. Must be called only if zoom is supported.
+     *
+     * @param level normalized zoom level. Value in range [0..1].
+     */
+    open fun setZoom(@FloatRange(from = 0.0, to = 1.0) level: Float) {
+        logger.recordMethod()
+
+        setZoomSafely(level)
+    }
+
+    /**
+     * Performs auto focus. This is a blocking operation which returns the result of the operation
+     * when auto focus completes.
+     */
+    open fun autoFocus(): FocusResult {
+        logger.recordMethod()
+
+        return camera.focusSafely()
+    }
+
+    /**
+     * Sets the point where the focus & exposure metering will happen.
+     */
+    open suspend fun setFocalPoint(focalRequest: FocalRequest) {
+        logger.recordMethod()
+
+        if (capabilities.await().canSetFocusingAreas()) {
+            camera.updateFocusingAreas(focalRequest)
+        }
+    }
+
+    /**
+     * Clears the point where the focus & exposure will happen.
+     */
+    open fun clearFocalPoint() {
+        logger.recordMethod()
+
+        camera.clearFocusingAreas()
+    }
+
+    /**
+     * Sets the desired surface on which the camera's preview will be displayed.
+     */
+    @Throws(IOException::class)
+    open fun setDisplaySurface(preview: Preview) {
+        logger.recordMethod()
+
+        surface = camera.setDisplaySurface(preview)
+    }
+
+    /**
+     * Attaches the camera to the [MediaRecorder].
+     */
+    open fun attachRecordingCamera(mediaRecorder: MediaRecorder) {
+        logger.recordMethod()
+
+        mediaRecorder.setCamera(camera)
+    }
+
+    /**
+     * Returns the [Resolution] of the displayed preview.
+     */
+    open fun getPreviewResolution(): Resolution {
+        logger.recordMethod()
+
+        val previewResolution = camera.getPreviewResolution(previewOrientation)
+
+        logger.log("Preview resolution is: $previewResolution")
+
+        return previewResolution
+    }
+
+
+    private fun setZoomSafely(@FloatRange(from = 0.0, to = 1.0) level: Float) {
+        try {
+            setZoomUnsafe(level)
+        } catch (e: Exception) {
+            logger.log("Unable to change zoom level to " + level + " e: " + e.message)
+        }
+    }
+
+    private fun setZoomUnsafe(@FloatRange(from = 0.0, to = 1.0) level: Float) {
+        (cachedCameraParameters ?: camera.parameters)
+                .apply {
+                    zoom = (maxZoom * level).toInt()
+                }
+                .cacheLocally()
+                .setInCamera()
+    }
+
+    private fun Camera.Parameters.cacheLocally() = apply {
+        cachedCameraParameters = this
+    }
+
+    private fun Camera.Parameters.setInCamera() = apply {
+        camera.parameters = this
+    }
+
+    private fun Camera.focusSafely(): FocusResult {
+        val latch = CountDownLatch(1)
+
+        try {
+            autoFocus { _, _ -> latch.countDown() }
+        } catch (e: Exception) {
+            logger.log("Failed to perform autofocus using device ${characteristics.cameraId} e: ${e.message}")
+
+            return FocusResult.UnableToFocus
+        }
+
+        try {
+            latch.await(AUTOFOCUS_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            // Do nothing
+        }
+
+        return FocusResult.Focused
+    }
+
+    private suspend fun Camera.updateFocusingAreas(focalRequest: FocalRequest) {
+        val focusingAreas = focalRequest.toFocusAreas(
+                displayOrientationDegrees = displayOrientation.degrees,
+                cameraIsMirrored = characteristics.isMirrored
+        )
+
+        parameters = parameters.apply {
+            with(capabilities.await()) {
+                if (maxMeteringAreas > 0) {
+                    meteringAreas = focusingAreas
+                }
+
+                if (maxFocusAreas > 0) {
+                    if (focusModes.contains(FocusMode.Auto)) {
+                        focusMode = FocusMode.Auto.toCode()
+                    }
+                    focusAreas = focusingAreas
+                }
+            }
+        }
+    }
+
+    private fun Camera.clearFocusingAreas() {
+        parameters = parameters.apply {
+            with(capabilities) {
+                meteringAreas = null
+                focusAreas = null
+            }
+        }
+    }
+
+}
+
+
+private const val AUTOFOCUS_TIMEOUT_SECONDS = 3L
+
+private fun Camera.takePhoto(imageRotation: Int): Photo {
+    val latch = CountDownLatch(1)
+    val photoReference = AtomicReference<Photo>()
+
+    takePicture(
+            null,
+            null,
+            null,
+            Camera.PictureCallback { data, _ ->
+                photoReference.set(
+                        Photo(data, imageRotation)
+                )
+
+                latch.countDown()
+            }
+    )
+
+    latch.await()
+
+    return photoReference.get()
+}
+
+@Throws(IOException::class)
+private fun Camera.setDisplaySurface(
+        preview: Preview
+): Surface = when (preview) {
+    is Preview.Texture -> preview.surfaceTexture
+            .also(this::setPreviewTexture)
+            .let(::Surface)
+
+    is Preview.Surface -> preview.surfaceHolder
+            .also(this::setPreviewDisplay)
+            .surface
+}
+
+private fun Camera.getPreviewResolution(previewOrientation: Orientation): Resolution {
+    return parameters.previewSize
+            .run {
+                PreviewSize(width, height)
+            }
+            .run {
+                when (previewOrientation) {
+                    is Orientation.Vertical -> this
+                    is Orientation.Horizontal -> flipDimensions()
+                }
+            }
+}
+
+private fun Capabilities.canSetFocusingAreas(): Boolean =
+        maxMeteringAreas > 0 || maxFocusAreas > 0

fotoapparat/src/main/java/io/fotoapparat/hardware/CameraException.java

@@ -1,20 +0,0 @@
-package io.fotoapparat.hardware;
-
-/**
- * A generic camera exception.
- */
-public class CameraException extends RuntimeException {
-
-    public CameraException(Exception e) {
-        super(e);
-    }
-
-    public CameraException(String message) {
-        super(message);
-    }
-
-    public CameraException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/Capabilities.java

@@ -1,155 +0,0 @@
-package io.fotoapparat.hardware;
-
-import android.support.annotation.NonNull;
-
-import java.util.Collections;
-import java.util.Set;
-
-import io.fotoapparat.parameter.Flash;
-import io.fotoapparat.parameter.FocusMode;
-import io.fotoapparat.parameter.Size;
-import io.fotoapparat.parameter.range.Range;
-import io.fotoapparat.parameter.range.Ranges;
-
-/**
- * Capabilities of camera hardware.
- */
-public class Capabilities {
-
-    @NonNull
-    private final Set<Size> photoSizes;
-    @NonNull
-    private final Set<Size> previewSizes;
-    @NonNull
-    private final Set<FocusMode> focusModes;
-    @NonNull
-    private final Set<Flash> flashModes;
-    @NonNull
-    private final Set<Range<Integer>> previewFpsRanges;
-    @NonNull
-    private final Range<Integer> sensorSensitivityRange;
-
-    private final boolean zoomSupported;
-
-    public Capabilities(@NonNull Set<Size> photoSizes,
-                        @NonNull Set<Size> previewSizes,
-                        @NonNull Set<FocusMode> focusModes,
-                        @NonNull Set<Flash> flashModes,
-                        @NonNull Set<Range<Integer>> previewFpsRanges,
-                        @NonNull Range<Integer> sensorSensitivityRange,
-                        boolean zoomSupported) {
-        this.photoSizes = photoSizes;
-        this.previewSizes = previewSizes;
-        this.focusModes = focusModes;
-        this.flashModes = flashModes;
-        this.previewFpsRanges = previewFpsRanges;
-        this.sensorSensitivityRange = sensorSensitivityRange;
-        this.zoomSupported = zoomSupported;
-    }
-
-    /**
-     * @return Empty {@link Capabilities}.
-     */
-    public static Capabilities empty() {
-        return new Capabilities(
-                Collections.<Size>emptySet(),
-                Collections.<Size>emptySet(),
-                Collections.<FocusMode>emptySet(),
-                Collections.<Flash>emptySet(),
-                Collections.<Range<Integer>>emptySet(),
-                Ranges.<Integer>emptyRange(),
-                false
-        );
-    }
-
-    /**
-     * @return list of supported picture sizes.
-     */
-    public Set<Size> supportedPictureSizes() {
-        return photoSizes;
-    }
-
-    /**
-     * @return list of supported preview sizes;
-     */
-    public Set<Size> supportedPreviewSizes() {
-        return previewSizes;
-    }
-
-    /**
-     * @return list of supported focus modes.
-     */
-    public Set<FocusMode> supportedFocusModes() {
-        return focusModes;
-    }
-
-    /**
-     * @return list of supported flash firing modes.
-     */
-    public Set<Flash> supportedFlashModes() {
-        return flashModes;
-    }
-
-    /**
-     * @return list of supported preview fps ranges.
-     */
-    public Set<Range<Integer>> supportedPreviewFpsRanges() {
-        return previewFpsRanges;
-    }
-
-    /**
-     * @return supported range of the sensor's sensitivity.
-     */
-    public Range<Integer> supportedSensorSensitivityRange() {
-        return sensorSensitivityRange;
-    }
-
-    /**
-     * @return {@code true} if zoom feature is supported. {@code false} if it is not supported.
-     */
-    public boolean isZoomSupported() {
-        return zoomSupported;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (!(o instanceof Capabilities)) return false;
-
-        Capabilities that = (Capabilities) o;
-
-        return zoomSupported == that.zoomSupported
-                && photoSizes.equals(that.photoSizes)
-                && previewSizes.equals(that.previewSizes)
-                && focusModes.equals(that.focusModes)
-                && flashModes.equals(that.flashModes)
-                && previewFpsRanges.equals(that.previewFpsRanges)
-                && sensorSensitivityRange.equals(that.sensorSensitivityRange);
-    }
-
-    @Override
-    public int hashCode() {
-        int result = photoSizes.hashCode();
-        result = 31 * result + previewSizes.hashCode();
-        result = 31 * result + focusModes.hashCode();
-        result = 31 * result + flashModes.hashCode();
-        result = 31 * result + previewFpsRanges.hashCode();
-        result = 31 * result + sensorSensitivityRange.hashCode();
-        result = 31 * result + (isZoomSupported() ? 1 : 0);
-        return result;
-    }
-
-    @Override
-    public String toString() {
-        return "Capabilities{" +
-                "photoSizes=" + photoSizes +
-                ", previewSizes=" + previewSizes +
-                ", focusModes=" + focusModes +
-                ", flashModes=" + flashModes +
-                ", previewFpsRanges=" + previewFpsRanges +
-                ", supportedSensorSensitivityRange=" + sensorSensitivityRange +
-                ", zoomSupported=" + zoomSupported +
-                '}';
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/Device.kt

@@ -0,0 +1,193 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.hardware
+
+import android.hardware.Camera
+import io.fotoapparat.characteristic.getCharacteristics
+import io.fotoapparat.concurrent.CameraExecutor
+import io.fotoapparat.configuration.CameraConfiguration
+import io.fotoapparat.configuration.Configuration
+import io.fotoapparat.exception.camera.UnsupportedLensException
+import io.fotoapparat.hardware.display.Display
+import io.fotoapparat.hardware.orientation.Orientation
+import io.fotoapparat.log.Logger
+import io.fotoapparat.parameter.ScaleType
+import io.fotoapparat.parameter.camera.CameraParameters
+import io.fotoapparat.parameter.camera.provide.getCameraParameters
+import io.fotoapparat.selector.LensPositionSelector
+import io.fotoapparat.util.FrameProcessor
+import io.fotoapparat.view.CameraRenderer
+import io.fotoapparat.view.FocalPointSelector
+import kotlinx.coroutines.experimental.CompletableDeferred
+
+
+/**
+ * Phone.
+ */
+internal open class Device(
+        internal open val logger: Logger,
+        private val display: Display,
+        internal open val scaleType: ScaleType,
+        internal open val cameraRenderer: CameraRenderer,
+        internal val focusPointSelector: FocalPointSelector?,
+        internal val executor: CameraExecutor,
+        numberOfCameras: Int = Camera.getNumberOfCameras(),
+        initialConfiguration: CameraConfiguration, initialLensPositionSelector: LensPositionSelector
+) {
+
+    private val cameras = (0 until numberOfCameras).map { cameraId ->
+        CameraDevice(
+                logger = logger,
+                characteristics = getCharacteristics(cameraId)
+        )
+    }
+
+    private var lensPositionSelector: LensPositionSelector = initialLensPositionSelector
+    private var selectedCameraDevice = CompletableDeferred<CameraDevice>()
+    private var savedConfiguration = CameraConfiguration.default()
+
+    init {
+        updateLensPositionSelector(initialLensPositionSelector)
+        savedConfiguration = initialConfiguration
+    }
+
+    /**
+     * Selects a camera.
+     */
+    open fun canSelectCamera(lensPositionSelector: LensPositionSelector): Boolean {
+        val selectedCameraDevice = selectCamera(
+                availableCameras = cameras,
+                lensPositionSelector = lensPositionSelector
+        )
+        return selectedCameraDevice != null
+    }
+
+    /**
+     * Selects a camera. Will do nothing if camera cannot be selected.
+     */
+    open fun selectCamera() {
+        logger.recordMethod()
+
+        selectCamera(
+                availableCameras = cameras,
+                lensPositionSelector = lensPositionSelector
+        )
+                ?.let(selectedCameraDevice::complete)
+                ?: selectedCameraDevice.completeExceptionally(UnsupportedLensException())
+    }
+
+    /**
+     * Clears the selected camera.
+     */
+    open fun clearSelectedCamera() {
+        selectedCameraDevice = CompletableDeferred()
+    }
+
+    /**
+     * Waits and returns the selected camera.
+     */
+    open suspend fun awaitSelectedCamera(): CameraDevice = selectedCameraDevice.await()
+
+    /**
+     * Returns the selected camera.
+     *
+     * @throws IllegalStateException If no camera has been yet selected.
+     * @throws UnsupportedLensException If no camera could get selected.
+     */
+    open fun getSelectedCamera(): CameraDevice = try {
+        selectedCameraDevice.getCompleted()
+    } catch (e: IllegalStateException) {
+        throw IllegalStateException("Camera has not started!")
+    }
+
+    /**
+     * @return `true` if a camera has been selected.
+     */
+    open fun hasSelectedCamera() = selectedCameraDevice.isCompleted
+
+    /**
+     * @return Orientation of the screen.
+     */
+    open fun getScreenOrientation(): Orientation {
+        return display.getOrientation()
+    }
+
+    /**
+     * Updates the desired from the user camera lens position.
+     */
+    open fun updateLensPositionSelector(newLensPosition: LensPositionSelector) {
+        logger.recordMethod()
+
+        lensPositionSelector = newLensPosition
+    }
+
+    /**
+     * Updates the desired from the user selectors.
+     */
+    open fun updateConfiguration(newConfiguration: Configuration) {
+        logger.recordMethod()
+
+        savedConfiguration = updateConfiguration(
+                savedConfiguration = savedConfiguration,
+                newConfiguration = newConfiguration
+        )
+    }
+
+    /**
+     * @return The desired from the user selectors.
+     */
+    open fun getConfiguration(): CameraConfiguration = savedConfiguration
+
+    /**
+     * @return The selected [CameraParameters] for the given [CameraDevice].
+     */
+    open suspend fun getCameraParameters(cameraDevice: CameraDevice): CameraParameters =
+            getCameraParameters(
+                    cameraConfiguration = savedConfiguration,
+                    capabilities = cameraDevice.getCapabilities()
+            )
+
+    /**
+     * @return The frame processor.
+     */
+    open fun getFrameProcessor(): FrameProcessor = savedConfiguration.frameProcessor
+
+    /**
+     * @return The desired from the user camera lens position.
+     */
+    open fun getLensPositionSelector(): LensPositionSelector = lensPositionSelector
+}
+
+/**
+ * Updates the device's configuration.
+ */
+internal fun updateConfiguration(
+        savedConfiguration: CameraConfiguration,
+        newConfiguration: Configuration
+) = CameraConfiguration(
+        flashMode = newConfiguration.flashMode ?: savedConfiguration.flashMode,
+        focusMode = newConfiguration.focusMode ?: savedConfiguration.focusMode,
+        exposureCompensation = newConfiguration.exposureCompensation ?: savedConfiguration.exposureCompensation,
+        frameProcessor = newConfiguration.frameProcessor ?: savedConfiguration.frameProcessor,
+        previewFpsRange = newConfiguration.previewFpsRange ?: savedConfiguration.previewFpsRange,
+        sensorSensitivity = newConfiguration.sensorSensitivity
+                ?: savedConfiguration.sensorSensitivity,
+        pictureResolution = newConfiguration.pictureResolution
+                ?: savedConfiguration.pictureResolution,
+        previewResolution = newConfiguration.previewResolution
+                ?: savedConfiguration.previewResolution
+)
+
+/**
+ * Selects a camera from the set of available ones.
+ */
+internal fun selectCamera(
+        availableCameras: List<CameraDevice>,
+        lensPositionSelector: LensPositionSelector
+): CameraDevice? {
+
+    val lensPositions = availableCameras.map { it.characteristics.lensPosition }.toSet()
+    val desiredPosition = lensPositionSelector(lensPositions)
+
+    return availableCameras.find { it.characteristics.lensPosition == desiredPosition }
+}

fotoapparat/src/main/java/io/fotoapparat/hardware/Executor.kt

@@ -0,0 +1,28 @@
+package io.fotoapparat.hardware
+
+import android.os.Handler
+import android.os.Looper
+import java.util.concurrent.Executors
+
+
+private val loggingExecutor = Executors.newSingleThreadExecutor()
+private val mainThreadHandler = Handler(Looper.getMainLooper())
+
+/**
+ * [java.util.concurrent.Executor] operating the [io.fotoapparat.result.PendingResult].
+ */
+internal val pendingResultExecutor = Executors.newSingleThreadExecutor()
+/**
+ * [java.util.concurrent.Executor] operating the [io.fotoapparat.preview.PreviewStream].
+ */
+internal val frameProcessingExecutor = Executors.newSingleThreadExecutor()
+
+/**
+ * Executes an operation in the main thread.
+ */
+internal fun executeLoggingThread(function: () -> Unit) = loggingExecutor.execute { function() }
+
+/**
+ * Executes an operation in the main thread.
+ */
+internal fun executeMainThread(function: () -> Unit) = mainThreadHandler.post { function() }

fotoapparat/src/main/java/io/fotoapparat/hardware/display/Display.kt

@@ -0,0 +1,32 @@
+package io.fotoapparat.hardware.display
+
+import android.content.Context
+import android.view.Surface
+import android.view.WindowManager
+import io.fotoapparat.hardware.orientation.Orientation
+import io.fotoapparat.hardware.orientation.Orientation.Horizontal.Landscape
+import io.fotoapparat.hardware.orientation.Orientation.Horizontal.ReverseLandscape
+import io.fotoapparat.hardware.orientation.Orientation.Vertical.Portrait
+import io.fotoapparat.hardware.orientation.Orientation.Vertical.ReversePortrait
+
+/**
+ * A phone's display.
+ */
+internal open class Display(context: Context) {
+
+    private val display = context.getDisplay()
+
+    /**
+     * Returns the orientation of the screen.
+     */
+    open fun getOrientation(): Orientation = when (display.rotation) {
+        Surface.ROTATION_0 -> Portrait
+        Surface.ROTATION_90 -> Landscape
+        Surface.ROTATION_180 -> ReversePortrait
+        Surface.ROTATION_270 -> ReverseLandscape
+        else -> Portrait
+    }
+
+}
+
+private fun Context.getDisplay() = (getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay

fotoapparat/src/main/java/io/fotoapparat/hardware/metering/FocalRequest.kt

@@ -0,0 +1,20 @@
+package io.fotoapparat.hardware.metering
+
+import io.fotoapparat.parameter.Resolution
+
+/**
+ * The request to focus camera at a particular point.
+ */
+data class FocalRequest(
+
+        /**
+         * The point where when user would like to focus.
+         */
+        val point: PointF,
+
+        /**
+         * Resolution of the preview
+         */
+        val previewResolution: Resolution
+)
+

fotoapparat/src/main/java/io/fotoapparat/hardware/metering/PointF.kt

@@ -0,0 +1,10 @@
+package io.fotoapparat.hardware.metering
+
+
+/**
+ * A point in arbitrary scale.
+ */
+data class PointF(
+        val x: Float,
+        val y: Float
+)

fotoapparat/src/main/java/io/fotoapparat/hardware/metering/convert/FocalPointConverter.kt

@@ -0,0 +1,117 @@
+@file:Suppress("DEPRECATION")
+
+package io.fotoapparat.hardware.metering.convert
+
+import android.graphics.Matrix
+import android.graphics.Rect
+import android.hardware.Camera
+import io.fotoapparat.hardware.metering.FocalRequest
+import io.fotoapparat.hardware.metering.PointF
+import io.fotoapparat.parameter.Resolution
+
+/**
+ * The weight of the camera area.
+ * Only 1will be used, so max weight, `1000`, is used.
+ */
+private const val WEIGHT = 1000
+
+/**
+ * From -1000 to 1000
+ *
+ * @see Camera.Area
+ */
+private const val CAMERA_BOUNDS_RANGE = 2000f
+
+/**
+ * The half dimension size of a focus area.
+ *
+ * The camera will focus on a maximum area of `(2 * this) ^ 2`.
+ */
+private const val FOCUS_AREA_HALF_SIZE = 50
+
+/**
+ * Converts a [FocalRequest] to a list of [Camera.Area] that the camera should focus at.
+ */
+internal fun FocalRequest.toFocusAreas(
+        displayOrientationDegrees: Int,
+        cameraIsMirrored: Boolean
+): List<Camera.Area> = listOf(Camera.Area(
+        focusBounds(
+                displayOrientationDegrees = displayOrientationDegrees.toFloat(),
+                cameraIsMirrored = cameraIsMirrored
+        ),
+        WEIGHT
+))
+
+private fun FocalRequest.focusBounds(
+        displayOrientationDegrees: Float,
+        cameraIsMirrored: Boolean
+): Rect = point
+        .adjustPointToCameraPreview(
+                previewResolution,
+                displayOrientationDegrees,
+                cameraIsMirrored
+        )
+        .toBoundsRect()
+
+private fun PointF.adjustPointToCameraPreview(
+        visibleResolution: Resolution,
+        displayOrientationDegrees: Float,
+        cameraIsMirrored: Boolean
+): PointF = Matrix()
+        .configMatrix(
+                visibleResolution,
+                displayOrientationDegrees,
+                cameraIsMirrored
+        )
+        .run {
+            floatArrayOf(x, y).also {
+                mapPoints(it)
+            }
+        }
+        .let {
+            PointF(
+                    it[0].verifyInBounds(),
+                    it[1].verifyInBounds()
+            )
+        }
+
+/**
+ * The point value should mainly be adjusted by `2000 * value - 1000`
+ * in order to be in `-1000..1000` range.
+ */
+private fun Matrix.configMatrix(
+        visibleResolution: Resolution,
+        displayOrientationDegrees: Float,
+        cameraIsMirrored: Boolean
+) = apply {
+    postScale(
+            CAMERA_BOUNDS_RANGE / visibleResolution.width.toFloat(),
+            CAMERA_BOUNDS_RANGE / visibleResolution.height.toFloat()
+    )
+    postTranslate(
+            -CAMERA_BOUNDS_RANGE / 2,
+            -CAMERA_BOUNDS_RANGE / 2
+    )
+    postRotate(-displayOrientationDegrees)
+    postScale(
+            if (cameraIsMirrored) -1f else 1f,
+            1f
+    )
+}
+
+private fun Float.verifyInBounds(): Float {
+    return takeIf { it in -1000f..1000f }
+            ?: throw IllegalArgumentException("Point value should be between -1000.0 and 1000.0. Was $this")
+}
+
+private fun PointF.toBoundsRect() = Rect(
+        (x - FOCUS_AREA_HALF_SIZE).ensureAreaBound(),
+        (y - FOCUS_AREA_HALF_SIZE).ensureAreaBound(),
+        (x + FOCUS_AREA_HALF_SIZE).ensureAreaBound(),
+        (y + FOCUS_AREA_HALF_SIZE).ensureAreaBound()
+)
+
+private fun Float.ensureAreaBound() = clamp(-1000f, 1000f).toInt()
+
+private fun Float.clamp(min: Float, max: Float): Float = Math.max(min, Math.min(this, max))

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/AutoFocusOperator.java

@@ -1,16 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.lens.FocusResult;
-
-/**
- * Performs auto focus.
- */
-public interface AutoFocusOperator {
-
-    /**
-     * Performs auto focus. This is a blocking operation which returns the result of the operation
-     * when auto focus completes.
-     */
-    FocusResult autoFocus();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/CapabilitiesOperator.java

@@ -1,17 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.hardware.Capabilities;
-
-/**
- * An interface which indicates that the class can
- * provide the camera capabilities.
- */
-public interface CapabilitiesOperator {
-
-    /**
-     * Returns the {@link Capabilities} of the opened camera.
-     *
-     * @return The {@link Capabilities} of the camera.
-     */
-    Capabilities getCapabilities();
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/CaptureOperator.java

@@ -1,17 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.photo.Photo;
-
-/**
- * An interface which indicates that the class can
- * capture still pictures.
- */
-public interface CaptureOperator {
-
-    /**
-     * Invokes a still picture capture action.
-     *
-     * @return The captured photo.
-     */
-    Photo takePicture();
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/ConnectionOperator.java

@@ -1,23 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.parameter.LensPosition;
-
-/**
- * An interface which indicates that the class can
- * open and close connections to a camera.
- */
-public interface ConnectionOperator {
-
-    /**
-     * Opens a connection to a camera.
-     *
-     * @param lensPosition The camera position relatively to the screen of the device,
-     *                     which will determine which camera to open.
-     */
-    void open(LensPosition lensPosition);
-
-    /**
-     * Closes the connection to a camera.
-     */
-    void close();
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/ExposureMeasurementOperator.java

@@ -1,13 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-/**
- * Measures the exposure.
- */
-public interface ExposureMeasurementOperator {
-
-    /**
-     * Measures the exposure. This is a blocking operation which returns when measurement completes.
-     */
-    void measureExposure();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/OrientationOperator.java

@@ -1,13 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-/**
- * An interface which indicates that the class can
- * handle the orientation updates.
- */
-public interface OrientationOperator {
-
-    /**
-     * Sets the current orientation of the display.
-     */
-    void setDisplayOrientation(int degrees);
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/ParametersOperator.java

@@ -1,15 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.parameter.Parameters;
-
-/**
- * An interface which indicates that the class can
- * support parameter updates.
- */
-public interface ParametersOperator {
-
-    /**
-     * Updates the desired parameters for the preview and the photo capture actions.
-     */
-    void updateParameters(Parameters parameters);
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/PreviewOperator.java

@@ -1,21 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-/**
- * An interface which indicates that the class can
- * start and stop the capture preview.
- */
-public interface PreviewOperator {
-
-    /**
-     * Starts the preview to the surface.
-     * <p>
-     * {@link #stopPreview()} should be called
-     * to stop the operation.
-     */
-    void startPreview();
-
-    /**
-     * Stops the preview from the surface.
-     */
-    void stopPreview();
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/PreviewStreamOperator.java

@@ -1,15 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.preview.PreviewStream;
-
-/**
- * Provides {@link PreviewStream} controlled by camera.
- */
-public interface PreviewStreamOperator {
-
-    /**
-     * @return {@link PreviewStream} associated with camera.
-     */
-    PreviewStream getPreviewStream();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/RendererParametersOperator.java

@@ -1,15 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import io.fotoapparat.parameter.RendererParameters;
-
-/**
- * Builds {@link RendererParameters}.
- */
-public interface RendererParametersOperator {
-
-    /**
-     * @return {@link RendererParameters}.
-     */
-    RendererParameters getRendererParameters();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/SurfaceOperator.java

@@ -1,13 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-/**
- * An interface which indicates that the class can
- * set a preview surface.
- */
-public interface SurfaceOperator {
-
-    /**
-     * Sets the desired surface on which the camera preview will be displayed.
-     */
-    void setDisplaySurface(Object displaySurface);
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/operators/ZoomOperator.java

@@ -1,17 +0,0 @@
-package io.fotoapparat.hardware.operators;
-
-import android.support.annotation.FloatRange;
-
-/**
- * Modifies zoom level of the camera.
- */
-public interface ZoomOperator {
-
-    /**
-     * Changes zoom level of the camera. Must be called only if zoom is supported.
-     *
-     * @param level normalized zoom level. Value in range [0..1].
-     */
-    void setZoom(@FloatRange(from = 0f, to = 1f) float level);
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/Orientation.kt

@@ -0,0 +1,56 @@
+package io.fotoapparat.hardware.orientation
+
+typealias DeviceOrientation = Orientation
+typealias ScreenOrientation = Orientation
+
+/**
+ * The device orientation.
+ */
+sealed class Orientation(
+        val degrees: Int
+) {
+
+    /**
+     * A vertical device orientation.
+     */
+    sealed class Vertical(degrees: Int) : Orientation(degrees) {
+
+        /**
+         * A vertical, normal orientation.
+         */
+        object Portrait : Vertical(0)
+
+        /**
+         * A reversed (flipped phone) orientation.
+         */
+        object ReversePortrait : Vertical(180)
+
+    }
+
+    /**
+     * A horizontal device orientation.
+     */
+    sealed class Horizontal(degrees: Int) : Orientation(degrees) {
+
+        /**
+         * A 90 degrees clockwise from "normal", orientation.
+         */
+        object Landscape : Horizontal(90)
+
+        /**
+         * A 90 degrees counter-clockwise from "normal", orientation.
+         */
+        object ReverseLandscape : Horizontal(270)
+
+    }
+}
+
+internal fun Int.toOrientation(): Orientation {
+    return when (this) {
+        0, 360 -> Orientation.Vertical.Portrait
+        90 -> Orientation.Horizontal.Landscape
+        180 -> Orientation.Vertical.ReversePortrait
+        270 -> Orientation.Horizontal.ReverseLandscape
+        else -> throw IllegalArgumentException("Cannot convert $this to absolute Orientation.")
+    }
+}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/OrientationResolver.kt

@@ -0,0 +1,75 @@
+package io.fotoapparat.hardware.orientation
+
+/**
+ * @param screenOrientation Orientation of the display.
+ * @param cameraOrientation Orientation of the camera sensor.
+ * @param cameraIsMirrored `true` if camera is mirrored (typically that is the case
+ * for front cameras). `false` if it is not mirrored.
+ *
+ * @return rotation of the image relatively to current device orientation.
+ */
+fun computePreviewOrientation(
+        screenOrientation: Orientation,
+        cameraOrientation: Orientation,
+        cameraIsMirrored: Boolean
+): Orientation {
+    val mirroredCameraModifier = if (cameraIsMirrored) -1 else 1
+
+    val rotation = (720
+            + mirroredCameraModifier * screenOrientation.degrees
+            - cameraOrientation.degrees
+            ) % 360
+
+    return rotation.toOrientation()
+}
+
+/**
+ * @param deviceOrientation Orientation of the device.
+ * @param cameraOrientation Orientation of the camera sensor.
+ * @param cameraIsMirrored `true` if camera is mirrored (typically that is the case
+ * for front cameras). `false` if it is not mirrored.
+ *
+ * @return clockwise rotation of the image relatively to current device orientation.
+ */
+internal fun computeImageOrientation(
+        deviceOrientation: Orientation,
+        cameraOrientation: Orientation,
+        cameraIsMirrored: Boolean
+): Orientation {
+    val screenOrientationDegrees = deviceOrientation.degrees
+    val cameraRotationDegrees = cameraOrientation.degrees
+
+    val rotation = if (cameraIsMirrored) {
+        360 - (cameraRotationDegrees - screenOrientationDegrees + 360) % 360
+    } else {
+        360 - (cameraRotationDegrees + screenOrientationDegrees) % 360
+    }
+
+    return rotation.toOrientation()
+}
+
+/**
+ * @param screenOrientation Orientation of the display.
+ * @param cameraOrientation Orientation of the camera sensor.
+ * @param cameraIsMirrored `true` if camera is mirrored (typically that is the case for
+ * front cameras). `false` if it is not mirrored.
+ *
+ * @return display orientation in which user will see the output camera in a correct rotation.
+ */
+internal fun computeDisplayOrientation(
+        screenOrientation: Orientation,
+        cameraOrientation: Orientation,
+        cameraIsMirrored: Boolean
+): Orientation {
+    val screenOrientationDegrees = screenOrientation.degrees
+    val cameraRotationDegrees = cameraOrientation.degrees
+
+    val rotation = if (cameraIsMirrored) {
+        (360 - (cameraRotationDegrees + screenOrientationDegrees) % 360) % 360
+    } else {
+        (cameraRotationDegrees - screenOrientationDegrees + 360) % 360
+    }
+
+    return rotation.toOrientation()
+}
+

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/OrientationSensor.java

@@ -1,61 +0,0 @@
-package io.fotoapparat.hardware.orientation;
-
-import android.support.annotation.NonNull;
-
-/**
- * Monitors orientation of the device.
- */
-public class OrientationSensor implements RotationListener.Listener {
-
-    private final RotationListener rotationListener;
-    private final ScreenOrientationProvider screenOrientationProvider;
-
-    private int lastKnownRotation;
-    private Listener listener;
-
-    public OrientationSensor(@NonNull final RotationListener rotationListener,
-                             @NonNull final ScreenOrientationProvider screenOrientationProvider) {
-        this.rotationListener = rotationListener;
-        this.screenOrientationProvider = screenOrientationProvider;
-
-        rotationListener.setRotationListener(this);
-    }
-
-    /**
-     * Starts monitoring device's orientation.
-     */
-    public void start(Listener listener) {
-        this.listener = listener;
-        rotationListener.enable();
-    }
-
-    /**
-     * Stops monitoring device's orientation.
-     */
-    public void stop() {
-        rotationListener.disable();
-        listener = null;
-    }
-
-    @Override
-    public void onRotationChanged() {
-        if (listener != null) {
-            int rotation = screenOrientationProvider.getScreenRotation();
-            if (rotation != lastKnownRotation) {
-                listener.onOrientationChanged(rotation);
-                lastKnownRotation = rotation;
-            }
-        }
-    }
-
-    /**
-     * Notified when orientation of the device is updated.
-     */
-    public interface Listener {
-
-        /**
-         * Called when orientation of the device is updated.
-         */
-        void onOrientationChanged(int degrees);
-    }
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/OrientationSensor.kt

@@ -0,0 +1,61 @@
+package io.fotoapparat.hardware.orientation
+
+import android.content.Context
+import io.fotoapparat.hardware.Device
+import io.fotoapparat.hardware.orientation.Orientation.Vertical.Portrait
+
+
+/**
+ * Monitors orientation of the device.
+ */
+internal open class OrientationSensor(
+        private val rotationListener: RotationListener,
+        private val device: Device
+) {
+
+    private val onOrientationChanged: (DeviceRotationDegrees) -> Unit = { deviceRotation ->
+        deviceRotation.toClosestRightAngle()
+                .toOrientation()
+                .takeIf { it != lastKnownDeviceOrientation }
+                ?.let {
+                    val state = OrientationState(
+                            deviceOrientation = it,
+                            screenOrientation = device.getScreenOrientation()
+                    )
+
+                    lastKnownDeviceOrientation = state.deviceOrientation
+                    listener(state)
+                }
+    }
+
+    private lateinit var listener: (OrientationState) -> Unit
+    private var lastKnownDeviceOrientation: Orientation = Portrait
+
+    constructor(
+            context: Context,
+            device: Device
+    ) : this(
+            RotationListener(context),
+            device
+    )
+
+    init {
+        rotationListener.orientationChanged = onOrientationChanged
+    }
+
+    /**
+     * Starts monitoring device's orientation state.
+     */
+    open fun start(listener: (OrientationState) -> Unit) {
+        this.listener = listener
+        rotationListener.enable()
+    }
+
+    /**
+     * Stops monitoring device's orientation.
+     */
+    open fun stop() {
+        rotationListener.disable()
+    }
+
+}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/OrientationState.kt

@@ -0,0 +1,16 @@
+package io.fotoapparat.hardware.orientation
+
+/**
+ * Phone orientation states.
+ */
+data class OrientationState(
+        /**
+         * The current orientation the device is being hold.
+         */
+        val deviceOrientation: DeviceOrientation,
+
+        /**
+         * The current orientation of the screen.
+         */
+        val screenOrientation: ScreenOrientation
+)

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/OrientationUtils.java

@@ -1,64 +0,0 @@
-package io.fotoapparat.hardware.orientation;
-
-/**
- * Utilities for working with device orientation.
- */
-public class OrientationUtils {
-
-    /**
-     * @return closest right angle to given value. That is: 0, 90, 180, 270.
-     */
-    public static int toClosestRightAngle(int degrees) {
-        boolean roundUp = degrees % 90 > 45;
-
-        int roundAppModifier = roundUp ? 1 : 0;
-
-        return (((degrees / 90) + roundAppModifier) * 90) % 360;
-    }
-
-    /**
-     * @param screenRotationDegrees rotation of the display (as provided by system) in degrees.
-     * @param cameraRotationDegrees rotation of the camera sensor relatively to device natural
-     *                              orientation.
-     * @param cameraIsMirrored      {@code true} if camera is mirrored (typically that is the case
-     *                              for front cameras). {@code false} if it is not mirrored.
-     * @return display orientation in which user will see the output camera in a correct rotation.
-     */
-    public static int computeDisplayOrientation(int screenRotationDegrees,
-                                                int cameraRotationDegrees,
-                                                boolean cameraIsMirrored) {
-        int degrees = OrientationUtils.toClosestRightAngle(screenRotationDegrees);
-
-        if (cameraIsMirrored) {
-            degrees = (cameraRotationDegrees + degrees) % 360;
-            degrees = (360 - degrees) % 360;
-        } else {
-            degrees = (cameraRotationDegrees - degrees + 360) % 360;
-        }
-
-        return degrees;
-    }
-
-    /**
-     * @param screenRotationDegrees rotation of the display (as provided by system) in degrees.
-     * @param cameraRotationDegrees rotation of the camera sensor relatively to device natural
-     *                              orientation.
-     * @param cameraIsMirrored      {@code true} if camera is mirrored (typically that is the case
-     *                              for front cameras). {@code false} if it is not mirrored.
-     * @return clockwise rotation of the image relatively to current device orientation.
-     */
-    public static int computeImageOrientation(int screenRotationDegrees,
-                                              int cameraRotationDegrees,
-                                              boolean cameraIsMirrored) {
-        int rotation;
-
-        if (cameraIsMirrored) {
-            rotation = -(screenRotationDegrees + cameraRotationDegrees);
-        } else {
-            rotation = screenRotationDegrees - cameraRotationDegrees;
-        }
-
-        return (rotation + 360 + 360) % 360;
-    }
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/Rotation.kt

@@ -0,0 +1,14 @@
+package io.fotoapparat.hardware.orientation
+
+typealias DeviceRotationDegrees = Int
+
+/**
+ * @return closest right angle to given value. That is: 0, 90, 180, 270.
+ */
+internal fun Int.toClosestRightAngle(): Int {
+    val roundUp = this % 90 > 45
+
+    val roundAppModifier = if (roundUp) 1 else 0
+
+    return (this / 90 + roundAppModifier) * 90 % 360
+}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/RotationListener.java

@@ -1,44 +0,0 @@
-package io.fotoapparat.hardware.orientation;
-
-import android.content.Context;
-import android.support.annotation.NonNull;
-import android.view.OrientationEventListener;
-
-/**
- * Wrapper around {@link OrientationEventListener} to notify when the device's rotation has changed.
- */
-public class RotationListener extends OrientationEventListener {
-
-    private Listener listener;
-
-    public RotationListener(Context context) {
-        super(context);
-    }
-
-    @Override
-    public void onOrientationChanged(int orientation) {
-        if (listener != null && canDetectOrientation()) {
-            listener.onRotationChanged();
-        }
-    }
-
-    /**
-     * Sets a listener to this class to notify future rotation events.
-     *
-     * @param listener The new listener
-     */
-    void setRotationListener(@NonNull Listener listener) {
-        this.listener = listener;
-    }
-
-    /**
-     * Notified when the rotation of the device is updated.
-     */
-    interface Listener {
-
-        /**
-         * Called when the rotation of the device has changed.
-         */
-        void onRotationChanged();
-    }
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/RotationListener.kt

@@ -0,0 +1,22 @@
+package io.fotoapparat.hardware.orientation
+
+import android.content.Context
+import android.view.OrientationEventListener
+
+
+/**
+ * Wrapper around [OrientationEventListener] to notify when the device's rotation has changed.
+ */
+internal open class RotationListener(
+        context: Context
+) : OrientationEventListener(context) {
+
+    lateinit var orientationChanged: (DeviceRotationDegrees) -> Unit
+
+    override fun onOrientationChanged(orientation: DeviceRotationDegrees) {
+        if (canDetectOrientation()) {
+            orientationChanged(orientation)
+        }
+    }
+
+}

fotoapparat/src/main/java/io/fotoapparat/hardware/orientation/ScreenOrientationProvider.java

@@ -1,39 +0,0 @@
-package io.fotoapparat.hardware.orientation;
-
-import android.content.Context;
-import android.support.annotation.NonNull;
-import android.view.Display;
-import android.view.Surface;
-import android.view.WindowManager;
-
-/**
- * Provides orientation of the screen.
- */
-public class ScreenOrientationProvider {
-
-    private final Display display;
-
-    public ScreenOrientationProvider(@NonNull Context context) {
-        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
-        display = windowManager.getDefaultDisplay();
-    }
-
-    /**
-     * @return rotation of the screen in degrees.
-     */
-    public int getScreenRotation() {
-        int rotation = display.getRotation();
-
-        switch (rotation) {
-            case Surface.ROTATION_90:
-                return 90;
-            case Surface.ROTATION_180:
-                return 180;
-            case Surface.ROTATION_270:
-                return 270;
-            case Surface.ROTATION_0:
-            default:
-                return 0;
-        }
-    }
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/provider/AvailableLensPositionsProvider.java

@@ -1,17 +0,0 @@
-package io.fotoapparat.hardware.provider;
-
-import java.util.List;
-
-import io.fotoapparat.parameter.LensPosition;
-
-/**
- * Provides list of {@link LensPosition} which are available on the device.
- */
-public interface AvailableLensPositionsProvider {
-
-    /**
-     * @return list of {@link LensPosition} which are available on the device.
-     */
-    List<LensPosition> getAvailableLensPositions();
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/provider/CameraProvider.java

@@ -1,15 +0,0 @@
-package io.fotoapparat.hardware.provider;
-
-import io.fotoapparat.hardware.CameraDevice;
-import io.fotoapparat.log.Logger;
-
-/**
- * Abstraction for providing camera.
- */
-public interface CameraProvider {
-
-    /**
-     * @return a {@link CameraDevice}.
-     */
-    CameraDevice get(Logger logger);
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/provider/CameraProviders.java

@@ -1,38 +0,0 @@
-package io.fotoapparat.hardware.provider;
-
-import android.content.Context;
-
-/**
- * Static factory for {@link CameraProvider}
- */
-public class CameraProviders {
-
-	private CameraProviders() {
-	}
-
-	/**
-	 * @return provider which uses Camera v2 on devices newer than Lollipop and falls back to Camera
-	 * v1 on older devices.
-	 */
-	public static CameraProvider defaultProvider(Context context) {
-		return new DefaultProvider(
-				v1(),
-				v2(context)
-		);
-	}
-
-	/**
-	 * @return provider for Camera v1.
-	 */
-	public static CameraProvider v1() {
-		return new V1Provider();
-	}
-
-	/**
-	 * @return provider for Camera v2.
-	 */
-	public static CameraProvider v2(Context context) {
-		return new V2Provider(context);
-	}
-
-}

fotoapparat/src/main/java/io/fotoapparat/hardware/provider/DefaultProvider.java

@@ -1,35 +0,0 @@
-package io.fotoapparat.hardware.provider;
-
-import io.fotoapparat.hardware.CameraDevice;
-import io.fotoapparat.log.Logger;
-import io.fotoapparat.util.SDKInfo;
-
-/**
- * Selects correct version of providers for a device.
- */
-public class DefaultProvider implements CameraProvider {
-
-	private final CameraProvider v1Provider;
-	private final CameraProvider v2Provider;
-	private final SDKInfo sdkInfo;
-
-	public DefaultProvider(CameraProvider v1Provider,
-						   CameraProvider v2Provider) {
-		this(v1Provider, v2Provider, SDKInfo.getInstance());
-	}
-
-	DefaultProvider(CameraProvider v1Provider,
-					CameraProvider v2Provider,
-					SDKInfo sdkInfo) {
-		this.v1Provider = v1Provider;
-		this.v2Provider = v2Provider;
-		this.sdkInfo = sdkInfo;
-	}
-
-	@Override
-	public CameraDevice get(Logger logger) {
-		return sdkInfo.isBellowLollipop()
-				? v1Provider.get(logger)
-				: v2Provider.get(logger);
-	}
-}