Support portrait mode for preview and saving pictures and video

app/src/main/AndroidManifest.xml

@@ -20,8 +20,7 @@
  android:theme="@android:style/Theme.Material.NoActionBar.Fullscreen">
 
  <activity android:name="com.dozingcatsoftware.vectorcamera.MainActivity"
- android:screenOrientation="landscape"
- android:configChanges="keyboard|keyboardHidden">
+ android:configChanges="orientation|screenSize|keyboard|keyboardHidden">
  <intent-filter>
  <action android:name="android.intent.action.MAIN" />
 
@@ -35,12 +34,12 @@
 
  <activity
  android:name="com.dozingcatsoftware.vectorcamera.ViewImageActivity"
- android:screenOrientation="landscape">
+ android:configChanges="orientation|screenSize">
  </activity>
 
  <activity
  android:name="com.dozingcatsoftware.vectorcamera.ViewVideoActivity"
- android:screenOrientation="landscape">
+ android:configChanges="orientation|screenSize">
  </activity>
 
  <activity android:name="com.dozingcatsoftware.vectorcamera.AboutActivity">

app/src/main/java/com/dozingcatsoftware/util/images.kt

@@ -19,6 +19,11 @@ fun getDisplaySize(context: Context): Size {
  return Size(metrics.widthPixels, metrics.heightPixels)
 }
 
+fun getLandscapeDisplaySize(context: Context): Size {
+ val ds = getDisplaySize(context)
+ return if (ds.width >= ds.height) ds else Size(ds.height, ds.width)
+}
+
 /**
  * Notifies the OS to index an image so it appears in apps that show media files. Allows optional
  * callback to notify client when the scan is completed, e.g. so it can access the "content" URI

app/src/main/java/com/dozingcatsoftware/vectorcamera/CameraImage.kt

@@ -19,6 +19,8 @@ data class CameraImage(val rs: RenderScript,
  val orientation: ImageOrientation, val status: CameraStatus,
  val timestamp: Long, val displaySize: Size = zeroSize) {
 
+ // width() and height() return the dimensions of the actual camera input, which is always
+ // landscape. In portrait orientation the rendered image will have the dimensioned swapped.
  fun width(): Int {
  return singleYuvAllocation?.type?.x ?: planarYuvAllocations!!.y.type.x
  }
@@ -34,6 +36,11 @@ data class CameraImage(val rs: RenderScript,
  rs, singleYuvAllocation, planarYuvAllocations, orientation, status, timestamp, ds)
  }
 
+ fun withDisplaySizeAndOrientation(ds: Size, o: ImageOrientation): CameraImage {
+ return CameraImage(
+ rs, singleYuvAllocation, planarYuvAllocations, o, status, timestamp, ds)
+ }
+
  fun resizedTo(size: Size): CameraImage {
  val resizeScript = ScriptIntrinsicResize.create(rs)
 

app/src/main/java/com/dozingcatsoftware/vectorcamera/CameraImageGenerator.kt

@@ -22,6 +22,7 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  var status = CameraStatus.CLOSED
  private var targetStatus = CameraStatus.CLOSED
  private var imageAllocationCallback: ((CameraImage) -> Unit)? = null
+ private var cameraClosedCallback: (() -> Unit)? = null
  private var handler = Handler()
 
  private val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId)
@@ -34,12 +35,11 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  val facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING)
  val isFrontFacing = (facing == CameraMetadata.LENS_FACING_FRONT)
  val orientation = cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION)
- if (isFrontFacing && orientation == 90 || !isFrontFacing && orientation == 270) {
- ImageOrientation.ROTATED_180
- }
- else {
- ImageOrientation.NORMAL
- }
+ val upsideDown =
+ (isFrontFacing && orientation == 90) || (!isFrontFacing && orientation == 270)
+ // X flipped if the camera front facing or the orientation is backwards, but not both.
+ Log.i(TAG, "isFrontFacing: ${isFrontFacing} upsideDown: ${upsideDown}")
+ ImageOrientation(xFlipped = (isFrontFacing != upsideDown), yFlipped = upsideDown)
  }()
 
  fun start(targetStatus: CameraStatus, targetSize: Size,
@@ -61,19 +61,24 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  }
  }
 
- fun stop() {
+ /**
+ * Stops the camera and invokes the callback after the camera is completely closed. This avoids
+ * errors that can occur when trying to open the camera while it's in the process of closing.
+ */
+ fun stop(closedCallback: (() -> Unit)? = null) {
  this.targetStatus = CameraStatus.CLOSED
+ this.cameraClosedCallback = closedCallback
  updateStatus(this.status)
  }
 
  private fun updateStatus(status: CameraStatus) {
- Log.i(TAG, "CameraStatus change: " + status)
+ Log.i(TAG, "CameraStatus change: ${status}, target=${targetStatus}")
  this.status = status
 
  if (this.targetStatus == CameraStatus.CLOSED) {
  if (this.status.isCapturing()) {
  this.status = CameraStatus.CLOSING
-stopCaptureSession()
+stopCamera()
  }
  }
  else if (this.targetStatus.isCapturing()) {
@@ -100,7 +105,7 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  }
  }
 
- fun openCamera() {
+private fun openCamera() {
  val manager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
  stopCamera()
  try {
@@ -111,8 +116,15 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  updateStatus(CameraStatus.OPENED)
  }
 
- override fun onDisconnected(cam: CameraDevice) {
+ override fun onClosed(cam: CameraDevice) {
+ Log.i(TAG, "camera onClosed")
  updateStatus(CameraStatus.CLOSED)
+ cameraClosedCallback?.invoke()
+ }
+
+ override fun onDisconnected(cam: CameraDevice) {
+ Log.i(TAG, "onDisconnected")
+ cam.close()
  }
 
  override fun onError(camera: CameraDevice, error: Int) {
@@ -157,6 +169,7 @@ class CameraImageGenerator(val context: Context, val rs: RenderScript,
  }
 
  override fun onClosed(session: CameraCaptureSession?) {
+ Log.i(TAG, "capture session onClosed, status=${status}")
  super.onClosed(session)
  updateStatus(CameraStatus.OPENED)
  }

app/src/main/java/com/dozingcatsoftware/vectorcamera/CreateVideoZipFileAsyncTask.kt

@@ -31,8 +31,8 @@ class CreateVideoZipFileAsyncTask(
  val videoReader = params[0]!!.videoReader
  val mediaLibrary = params[0]!!.mediaLibrary
  val videoId = params[0]!!.videoId
- val videoWidth = videoReader.videoWidth()
- val videoHeight = videoReader.videoHeight()
+ val videoWidth = videoReader.landscapeVideoWidth()
+ val videoHeight = videoReader.landscapeVideoHeight()
 
  // Frames are JPEGs because PNG encoding is very slow.
  zipFile = mediaLibrary.videoFramesArchiveForItemId(videoId)

app/src/main/java/com/dozingcatsoftware/vectorcamera/ImageOrientation.kt

@@ -1,24 +1,11 @@
 package com.dozingcatsoftware.vectorcamera
 
-enum class ImageOrientation {
- NORMAL,
- ROTATED_180,
- ;
+class ImageOrientation(
+ val xFlipped: Boolean, val yFlipped: Boolean, val portrait: Boolean = false) {
 
- fun isXFlipped(): Boolean {
- return this == ROTATED_180
- }
-
- fun isYFlipped(): Boolean {
- return this == ROTATED_180
- }
+ fun withPortrait(newPortrait: Boolean) = ImageOrientation(xFlipped, yFlipped, newPortrait)
 
  companion object {
- fun withXYFlipped(xFlipped: Boolean, yFlipped: Boolean): ImageOrientation {
- if (xFlipped != yFlipped) {
- throw IllegalArgumentException("Only 0 and 180 degree rotations supported")
- }
- return if (xFlipped) ImageOrientation.ROTATED_180 else ImageOrientation.NORMAL
- }
+ val NORMAL = ImageOrientation(false, false)
  }
-}
+}

app/src/main/java/com/dozingcatsoftware/vectorcamera/MainActivity.kt

@@ -2,22 +2,25 @@ package com.dozingcatsoftware.vectorcamera
 
 import android.app.Activity
 import android.content.Intent
+import android.content.res.Configuration
 import android.os.Bundle
 import android.os.Handler
 import android.preference.PreferenceManager
 import android.provider.MediaStore
 import android.renderscript.RenderScript
 import android.util.Log
 import android.util.Size
-import android.view.MotionEvent
-import android.view.View
-import android.view.Window
 import com.dozingcatsoftware.vectorcamera.effect.CombinationEffect
 import com.dozingcatsoftware.vectorcamera.effect.Effect
 import com.dozingcatsoftware.vectorcamera.effect.EffectRegistry
-import com.dozingcatsoftware.util.getDisplaySize
+import com.dozingcatsoftware.util.getLandscapeDisplaySize
 import kotlinx.android.synthetic.main.activity_main.*
 import java.io.FileOutputStream
+import android.view.*
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+
+
 
 enum class ShutterMode {IMAGE, VIDEO}
 
@@ -34,7 +37,6 @@ class MainActivity : Activity() {
  private val photoLibrary = PhotoLibrary.defaultLibrary()
 
  private lateinit var rs: RenderScript
- private lateinit var displaySize: Size
  private val allEffectFactories = EffectRegistry.defaultEffectFactories()
  private var currentEffect: Effect? = null
  private var previousEffect: Effect? = null
@@ -48,13 +50,14 @@ class MainActivity : Activity() {
  private lateinit var previousImageSize: ImageSize
  private var shutterMode = ShutterMode.IMAGE
 
+ private var layoutIsPortrait = false
+
  override fun onCreate(savedInstanceState: Bundle?) {
  super.onCreate(savedInstanceState)
  requestWindowFeature(Window.FEATURE_NO_TITLE)
  setContentView(R.layout.activity_main)
  PreferenceManager.setDefaultValues(this.baseContext, R.xml.preferences, false)
 
- displaySize = getDisplaySize(this)
  // Use PROFILE type only on first run?
  rs = RenderScript.create(this, RenderScript.ContextType.NORMAL)
  imageProcessor = CameraImageProcessor(rs)
@@ -92,9 +95,16 @@ class MainActivity : Activity() {
 
  override fun onResume() {
  super.onResume()
- // TODO: Read high quality flag from preferences.
  checkPermissionAndStartCamera()
  overlayView.systemUiVisibility = View.SYSTEM_UI_FLAG_LOW_PROFILE
+
+ // View size is zero in onResume, have to wait for layout notification.
+ var listener: ViewTreeObserver.OnGlobalLayoutListener? = null
+ listener = ViewTreeObserver.OnGlobalLayoutListener {
+ updateLayout(isPortraitOrientation())
+ overlayView.viewTreeObserver.removeOnGlobalLayoutListener(listener)
+ }
+ overlayView.viewTreeObserver.addOnGlobalLayoutListener(listener)
  }
 
  override fun onPause() {
@@ -111,6 +121,15 @@ class MainActivity : Activity() {
  super.onPause()
  }
 
+ override fun onConfigurationChanged(newConfig: Configuration) {
+ Log.i(TAG, "configurationChanged: ${newConfig.orientation}")
+ super.onConfigurationChanged(newConfig)
+ val isPortrait = newConfig.orientation == Configuration.ORIENTATION_PORTRAIT
+ if (isPortrait != layoutIsPortrait) {
+ updateLayout(isPortrait)
+ }
+ }
+
  override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
  super.onActivityResult(requestCode, resultCode, intent)
 
@@ -156,12 +175,47 @@ class MainActivity : Activity() {
  if (preferredImageSize == ImageSize.FULL_SCREEN) 1.0f else 0.5f
  }
 
+ fun updateLayout(isPortrait: Boolean) {
+ Log.i(TAG, "updateLayout: ${isPortrait}")
+ layoutIsPortrait = isPortrait
+ val layoutWidth =
+ if (isPortrait) FrameLayout.LayoutParams.MATCH_PARENT
+ else FrameLayout.LayoutParams.WRAP_CONTENT
+ val layoutHeight =
+ if (isPortrait) FrameLayout.LayoutParams.WRAP_CONTENT
+ else FrameLayout.LayoutParams.MATCH_PARENT
+ val orientation = if (isPortrait) LinearLayout.HORIZONTAL else LinearLayout.VERTICAL
+ val direction =
+ if (isPortrait) LinearLayout.LAYOUT_DIRECTION_RTL
+ else LinearLayout.LAYOUT_DIRECTION_LTR
+
+ run {
+ val params = FrameLayout.LayoutParams(layoutWidth, layoutHeight)
+ params.gravity = if (isPortrait) Gravity.TOP else Gravity.LEFT
+ leftTopControlBar.layoutParams = params
+ leftTopControlBar.orientation = orientation
+ leftTopControlBar.layoutDirection = direction
+ }
+ run {
+ val params = FrameLayout.LayoutParams(layoutWidth, layoutHeight)
+ params.gravity = if (isPortrait) Gravity.BOTTOM else Gravity.RIGHT
+ rightBottomControlBar.layoutParams = params
+ rightBottomControlBar.orientation = orientation
+ rightBottomControlBar.layoutDirection = direction
+ }
+ }
+
+ private fun isPortraitOrientation(): Boolean {
+ return overlayView.height > overlayView.width
+ }
+
  private fun targetCameraImageSize(): Size {
+ val ds = getLandscapeDisplaySize(this)
  return when (preferredImageSize) {
- ImageSize.FULL_SCREEN -> displaySize
- ImageSize.HALF_SCREEN -> Size(displaySize.width / 2, displaySize.height / 2)
+ ImageSize.FULL_SCREEN -> ds
+ ImageSize.HALF_SCREEN -> Size(ds.width / 2, ds.height / 2)
  ImageSize.VIDEO_RECORDING -> Size(640, 360)
- ImageSize.EFFECT_GRID -> Size(displaySize.width / 4, displaySize.height / 4)
+ ImageSize.EFFECT_GRID -> Size(ds.width / 4, ds.height / 4)
  }
  }
 
@@ -247,8 +301,11 @@ class MainActivity : Activity() {
 
  private fun handleAllocationFromCamera(imageFromCamera: CameraImage) {
  handler.post(fun() {
- // Slightly ugly but some effects need the display size.
- val cameraImage = imageFromCamera.withDisplaySize(displaySize)
+ // Add fields that the image generator doesn't have. Might be better to have a separate
+ // class that holds a CameraImage, display size, and portrait flag.
+ val ds = getLandscapeDisplaySize(this)
+ val orientation = imageFromCamera.orientation.withPortrait(isPortraitOrientation())
+ val cameraImage = imageFromCamera.withDisplaySizeAndOrientation(ds, orientation)
  if (cameraImage.status == CameraStatus.CAPTURING_PHOTO) {
  Log.i(TAG, "Restarting preview capture")
  restartCameraImageGenerator()
@@ -281,10 +338,13 @@ class MainActivity : Activity() {
  }
  imageProcessor.pause()
  cameraSelector.selectNextCamera()
- cameraImageGenerator.stop()
- cameraImageGenerator = cameraSelector.createImageGenerator(rs)
- restartCameraImageGenerator()
- updateControls()
+ cameraImageGenerator.stop({
+ handler.post({
+ cameraImageGenerator = cameraSelector.createImageGenerator(rs)
+ restartCameraImageGenerator()
+ updateControls()
+ })
+ })
  }
 
  private fun switchResolution(view: View) {

app/src/main/java/com/dozingcatsoftware/vectorcamera/MediaMetadata.kt

@@ -18,8 +18,9 @@ data class MediaMetadata(val mediaType: MediaType, val effectMetadata: EffectMet
  "type" to mediaType.name.toLowerCase(),
  "width" to width,
  "height" to height,
- "xFlipped" to orientation.isXFlipped(),
- "yFlipped" to orientation.isYFlipped(),
+ "xFlipped" to orientation.xFlipped,
+ "yFlipped" to orientation.yFlipped,
+ "portrait" to orientation.portrait,
  "timestamp" to timestamp,
  "frameTimestamps" to frameTimestamps,
  "audioStartTimestamp" to audioStartTimestamp,
@@ -54,8 +55,9 @@ data class MediaMetadata(val mediaType: MediaType, val effectMetadata: EffectMet
  EffectMetadata.fromJson(effectDict),
  (json["width"] as Number).toInt(),
  (json["height"] as Number).toInt(),
- ImageOrientation.withXYFlipped(
- json["xFlipped"] as Boolean, json["yFlipped"] as Boolean),
+ ImageOrientation(
+ json["xFlipped"] as Boolean, json["yFlipped"] as Boolean,
+ json.getOrElse("portrait", {false}) as Boolean),
  json["timestamp"] as Long,
  frameTimestamps as List<Long>,
  audioStartTimestamp.toLong(),