Merge "Camera: Keep sensor orientation consistent with device fold state" into sc-v2-dev (01d8df41) · Commits · e / os / android_frameworks_base

core/api/current.txt

+7 −0

Original line number	Diff line number	Diff line
		@@ -17949,6 +17949,7 @@ package android.hardware.camera2 {
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<int[]> EDGE_AVAILABLE_EDGE_MODES;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<java.lang.Boolean> FLASH_INFO_AVAILABLE;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<int[]> HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<android.hardware.camera2.params.DeviceStateOrientationMap> INFO_DEVICE_STATE_ORIENTATION_MAP;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<java.lang.Integer> INFO_SUPPORTED_HARDWARE_LEVEL;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<java.lang.String> INFO_VERSION;
		field @NonNull public static final android.hardware.camera2.CameraCharacteristics.Key<android.util.Size[]> JPEG_AVAILABLE_THUMBNAIL_SIZES;
		@@ -18643,6 +18644,12 @@ package android.hardware.camera2.params {
		method public android.util.Rational getElement(int, int);
		}

		public final class DeviceStateOrientationMap {
		method public int getSensorOrientation(long);
		field public static final long FOLDED = 4L; // 0x4L
		field public static final long NORMAL = 0L; // 0x0L
		}

		public final class ExtensionSessionConfiguration {
		ctor public ExtensionSessionConfiguration(int, @NonNull java.util.List<android.hardware.camera2.params.OutputConfiguration>, @NonNull java.util.concurrent.Executor, @NonNull android.hardware.camera2.CameraExtensionSession.StateCallback);
		method @NonNull public java.util.concurrent.Executor getExecutor();

core/java/android/hardware/camera2/CameraCharacteristics.java

+113 −2

Original line number	Diff line number	Diff line
		@@ -22,15 +22,18 @@ import android.compat.annotation.UnsupportedAppUsage;
		import android.hardware.camera2.impl.CameraMetadataNative;
		import android.hardware.camera2.impl.PublicKey;
		import android.hardware.camera2.impl.SyntheticKey;
		import android.hardware.camera2.params.DeviceStateOrientationMap;
		import android.hardware.camera2.params.RecommendedStreamConfigurationMap;
		import android.hardware.camera2.params.SessionConfiguration;
		import android.hardware.camera2.utils.TypeReference;
		import android.os.Build;
		import android.util.Log;
		import android.util.Rational;

		import com.android.internal.annotations.GuardedBy;

		import java.util.ArrayList;
		import java.util.Collections;
		import java.util.HashSet;
		import java.util.List;
		import java.util.Set;

		@@ -202,8 +205,25 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		private List<CaptureResult.Key<?>> mAvailableResultKeys;
		private ArrayList<RecommendedStreamConfigurationMap> mRecommendedConfigurations;

		private final Object mLock = new Object();
		@GuardedBy("mLock")
		private boolean mFoldedDeviceState;

		private final CameraManager.DeviceStateListener mFoldStateListener =
		new CameraManager.DeviceStateListener() {
		@Override
		public final void onDeviceStateChanged(boolean folded) {
		synchronized (mLock) {
		mFoldedDeviceState = folded;
		}
		}};

		private static final String TAG = "CameraCharacteristics";

		/**
		* Takes ownership of the passed-in properties object
		*
		* @param properties Camera properties.
		* @hide
		*/
		public CameraCharacteristics(CameraMetadataNative properties) {
		@@ -219,6 +239,41 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		return new CameraMetadataNative(mProperties);
		}

		/**
		* Return the device state listener for this Camera characteristics instance
		*/
		CameraManager.DeviceStateListener getDeviceStateListener() { return mFoldStateListener; }

		/**
		* Overrides the property value
		*
		* <p>Check whether a given property value needs to be overridden in some specific
		* case.</p>
		*
		* @param key The characteristics field to override.
		* @return The value of overridden property, or {@code null} if the property doesn't need an
		* override.
		*/
		@Nullable
		private <T> T overrideProperty(Key<T> key) {
		if (CameraCharacteristics.SENSOR_ORIENTATION.equals(key) && (mFoldStateListener != null) &&
		(mProperties.get(CameraCharacteristics.INFO_DEVICE_STATE_ORIENTATIONS) != null)) {
		DeviceStateOrientationMap deviceStateOrientationMap =
		mProperties.get(CameraCharacteristics.INFO_DEVICE_STATE_ORIENTATION_MAP);
		synchronized (mLock) {
		Integer ret = deviceStateOrientationMap.getSensorOrientation(mFoldedDeviceState ?
		DeviceStateOrientationMap.FOLDED : DeviceStateOrientationMap.NORMAL);
		if (ret >= 0) {
		return (T) ret;
		} else {
		Log.w(TAG, "No valid device state to orientation mapping! Using default!");
		}
		}
		}

		return null;
		}

		/**
		* Get a camera characteristics field value.
		*
		@@ -235,7 +290,8 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		*/
		@Nullable
		public <T> T get(Key<T> key) {
		return mProperties.get(key);
		T propertyOverride = overrideProperty(key);
		return (propertyOverride != null) ? propertyOverride : mProperties.get(key);
		}

		/**
		@@ -3993,11 +4049,26 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		* upright on the device screen in its native orientation.</p>
		* <p>Also defines the direction of rolling shutter readout, which is from top to bottom in
		* the sensor's coordinate system.</p>
		* <p>Starting with Android API level 32, camera clients that query the orientation via
		* {@link android.hardware.camera2.CameraCharacteristics#get } on foldable devices which
		* include logical cameras can receive a value that can dynamically change depending on the
		* device/fold state.
		* Clients are advised to not cache or store the orientation value of such logical sensors.
		* In case repeated queries to CameraCharacteristics are not preferred, then clients can
		* also access the entire mapping from device state to sensor orientation in
		* {@link android.hardware.camera2.params.DeviceStateOrientationMap }.
		* Do note that a dynamically changing sensor orientation value in camera characteristics
		* will not be the best way to establish the orientation per frame. Clients that want to
		* know the sensor orientation of a particular captured frame should query the
		* {@link CaptureResult#LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID android.logicalMultiCamera.activePhysicalId} from the corresponding capture result and
		* check the respective physical camera orientation.</p>
		* <p><b>Units</b>: Degrees of clockwise rotation; always a multiple of
		* 90</p>
		* <p><b>Range of valid values:</b><br>
		* 0, 90, 180, 270</p>
		* <p>This key is available on all devices.</p>
		*
		* @see CaptureResult#LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID
		*/
		@PublicKey
		@NonNull
		@@ -4306,6 +4377,46 @@ public final class CameraCharacteristics extends CameraMetadata<CameraCharacteri
		public static final Key<String> INFO_VERSION =
		new Key<String>("android.info.version", String.class);

		/**
		* <p>This lists the mapping between a device folding state and
		* specific camera sensor orientation for logical cameras on a foldable device.</p>
		* <p>Logical cameras on foldable devices can support sensors with different orientation
		* values. The orientation value may need to change depending on the specific folding
		* state. Information about the mapping between the device folding state and the
		* sensor orientation can be obtained in
		* {@link android.hardware.camera2.params.DeviceStateOrientationMap }.
		* Device state orientation maps are optional and maybe present on devices that support
		* {@link CaptureRequest#SCALER_ROTATE_AND_CROP android.scaler.rotateAndCrop}.</p>
		* <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p>
		* <p><b>Limited capability</b> -
		* Present on all camera devices that report being at least {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED HARDWARE_LEVEL_LIMITED} devices in the
		* {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL android.info.supportedHardwareLevel} key</p>
		*
		* @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL
		* @see CaptureRequest#SCALER_ROTATE_AND_CROP
		*/
		@PublicKey
		@NonNull
		@SyntheticKey
		public static final Key<android.hardware.camera2.params.DeviceStateOrientationMap> INFO_DEVICE_STATE_ORIENTATION_MAP =
		new Key<android.hardware.camera2.params.DeviceStateOrientationMap>("android.info.deviceStateOrientationMap", android.hardware.camera2.params.DeviceStateOrientationMap.class);

		/**
		* <p>HAL must populate the array with
		* (hardware::camera::provider::V2_5::DeviceState, sensorOrientation) pairs for each
		* supported device state bitwise combination.</p>
		* <p><b>Units</b>: (device fold state, sensor orientation) x n</p>
		* <p><b>Optional</b> - The value for this key may be {@code null} on some devices.</p>
		* <p><b>Limited capability</b> -
		* Present on all camera devices that report being at least {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED HARDWARE_LEVEL_LIMITED} devices in the
		* {@link CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL android.info.supportedHardwareLevel} key</p>
		*
		* @see CameraCharacteristics#INFO_SUPPORTED_HARDWARE_LEVEL
		* @hide
		*/
		public static final Key<long[]> INFO_DEVICE_STATE_ORIENTATIONS =
		new Key<long[]>("android.info.deviceStateOrientations", long[].class);

		/**
		* <p>The maximum number of frames that can occur after a request
		* (different than the previous) has been submitted, and before the

core/java/android/hardware/camera2/CameraManager.java

+84 −2

Original line number	Diff line number	Diff line
		@@ -30,15 +30,19 @@ import android.hardware.ICameraServiceListener;
		import android.hardware.camera2.impl.CameraDeviceImpl;
		import android.hardware.camera2.impl.CameraInjectionSessionImpl;
		import android.hardware.camera2.impl.CameraMetadataNative;
		import android.hardware.camera2.params.DeviceStateOrientationMap;
		import android.hardware.camera2.params.ExtensionSessionConfiguration;
		import android.hardware.camera2.params.SessionConfiguration;
		import android.hardware.camera2.params.StreamConfiguration;
		import android.hardware.camera2.utils.CameraIdAndSessionConfiguration;
		import android.hardware.camera2.utils.ConcurrentCameraIdCombination;
		import android.hardware.devicestate.DeviceStateManager;
		import android.hardware.display.DisplayManager;
		import android.os.Binder;
		import android.os.DeadObjectException;
		import android.os.Handler;
		import android.os.HandlerExecutor;
		import android.os.HandlerThread;
		import android.os.IBinder;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		@@ -50,6 +54,10 @@ import android.util.Log;
		import android.util.Size;
		import android.view.Display;

		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.util.ArrayUtils;

		import java.lang.ref.WeakReference;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Comparator;
		@@ -97,6 +105,80 @@ public final class CameraManager {
		synchronized(mLock) {
		mContext = context;
		}

		mHandlerThread = new HandlerThread(TAG);
		mHandlerThread.start();
		mHandler = new Handler(mHandlerThread.getLooper());
		mFoldStateListener = new FoldStateListener(context);
		context.getSystemService(DeviceStateManager.class)
		.registerCallback(new HandlerExecutor(mHandler), mFoldStateListener);
		}

		private HandlerThread mHandlerThread;
		private Handler mHandler;
		private FoldStateListener mFoldStateListener;
		@GuardedBy("mLock")
		private ArrayList<WeakReference<DeviceStateListener>> mDeviceStateListeners = new ArrayList<>();
		private boolean mFoldedDeviceState;

		/**
		* @hide
		*/
		public interface DeviceStateListener {
		void onDeviceStateChanged(boolean folded);
		}

		private final class FoldStateListener implements DeviceStateManager.DeviceStateCallback {
		private final int[] mFoldedDeviceStates;

		public FoldStateListener(Context context) {
		mFoldedDeviceStates = context.getResources().getIntArray(
		com.android.internal.R.array.config_foldedDeviceStates);
		}

		private void handleStateChange(int state) {
		boolean folded = ArrayUtils.contains(mFoldedDeviceStates, state);
		synchronized (mLock) {
		mFoldedDeviceState = folded;
		ArrayList<WeakReference<DeviceStateListener>> invalidListeners = new ArrayList<>();
		for (WeakReference<DeviceStateListener> listener : mDeviceStateListeners) {
		DeviceStateListener callback = listener.get();
		if (callback != null) {
		callback.onDeviceStateChanged(folded);
		} else {
		invalidListeners.add(listener);
		}
		}
		if (!invalidListeners.isEmpty()) {
		mDeviceStateListeners.removeAll(invalidListeners);
		}
		}
		}

		@Override
		public final void onBaseStateChanged(int state) {
		handleStateChange(state);
		}

		@Override
		public final void onStateChanged(int state) {
		handleStateChange(state);
		}
		}

		/**
		* Register a {@link CameraCharacteristics} device state listener
		*
		* @param chars Camera characteristics that need to receive device state updates
		*
		* @hide
		*/
		public void registerDeviceStateListener(@NonNull CameraCharacteristics chars) {
		synchronized (mLock) {
		DeviceStateListener listener = chars.getDeviceStateListener();
		listener.onDeviceStateChanged(mFoldedDeviceState);
		mDeviceStateListeners.add(new WeakReference<>(listener));
		}
		}

		/**
		@@ -504,6 +586,7 @@ public final class CameraManager {
		"Camera service is currently unavailable", e);
		}
		}
		registerDeviceStateListener(characteristics);
		return characteristics;
		}

		@@ -1327,8 +1410,7 @@ public final class CameraManager {
		private ICameraService mCameraService;

		// Singleton, don't allow construction
		private CameraManagerGlobal() {
		}
		private CameraManagerGlobal() { }

		public static final boolean sCameraServiceDisabled =
		SystemProperties.getBoolean("config.disable_cameraservice", false);

core/java/android/hardware/camera2/impl/CameraMetadataNative.java

+23 −1

Original line number	Diff line number	Diff line
		@@ -50,6 +50,7 @@ import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfiguration
		import android.hardware.camera2.marshal.impl.MarshalQueryableStreamConfigurationDuration;
		import android.hardware.camera2.marshal.impl.MarshalQueryableString;
		import android.hardware.camera2.params.Capability;
		import android.hardware.camera2.params.DeviceStateOrientationMap;
		import android.hardware.camera2.params.Face;
		import android.hardware.camera2.params.HighSpeedVideoConfiguration;
		import android.hardware.camera2.params.LensShadingMap;
		@@ -761,6 +762,15 @@ public class CameraMetadataNative implements Parcelable {
		return (T) metadata.getLensShadingMap();
		}
		});
		sGetCommandMap.put(
		CameraCharacteristics.INFO_DEVICE_STATE_ORIENTATION_MAP.getNativeKey(),
		new GetCommand() {
		@Override
		@SuppressWarnings("unchecked")
		public <T> T getValue(CameraMetadataNative metadata, Key<T> key) {
		return (T) metadata.getDeviceStateOrientationMap();
		}
		});
		sGetCommandMap.put(
		CaptureResult.STATISTICS_OIS_SAMPLES.getNativeKey(),
		new GetCommand() {
		@@ -994,6 +1004,18 @@ public class CameraMetadataNative implements Parcelable {
		return map;
		}

		private DeviceStateOrientationMap getDeviceStateOrientationMap() {
		long[] mapArray = getBase(CameraCharacteristics.INFO_DEVICE_STATE_ORIENTATIONS);

		// Do not warn if map is null while s is not. This is valid.
		if (mapArray == null) {
		return null;
		}

		DeviceStateOrientationMap map = new DeviceStateOrientationMap(mapArray);
		return map;
		}

		private Location getGpsLocation() {
		String processingMethod = get(CaptureResult.JPEG_GPS_PROCESSING_METHOD);
		double[] coords = get(CaptureResult.JPEG_GPS_COORDINATES);

core/java/android/hardware/camera2/params/DeviceStateOrientationMap.java

0 → 100644

+155 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package android.hardware.camera2.params;

		import android.annotation.LongDef;
		import android.hardware.camera2.CameraCharacteristics;
		import android.hardware.camera2.utils.HashCodeHelpers;

		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;
		import java.util.Arrays;
		import java.util.HashMap;
		import java.util.Objects;

		/**
		* Immutable class that maps the device fold state to sensor orientation.
		*
		* <p>Some {@link CameraCharacteristics#REQUEST_AVAILABLE_CAPABILITIES_LOGICAL_MULTI_CAMERA logical}
		* cameras on foldables can include physical sensors with different sensor orientation
		* values. As a result, the values of the logical camera device can potentially change depending
		* on the device fold state.</p>
		*
		* <p>The device fold state to sensor orientation map will contain information about the
		* respective logical camera sensor orientation given a device state. Clients
		* can query the mapping for all possible supported folded states.
		*
		* @see CameraCharacteristics#SENSOR_ORIENTATION
		*/
		public final class DeviceStateOrientationMap {
		/**
		* Needs to be kept in sync with the HIDL/AIDL DeviceState
		*/

		/**
		* The device is in its normal physical configuration. This is the default if the
		* device does not support multiple different states.
		*/
		public static final long NORMAL = 0;

		/**
		* The device is folded. If not set, the device is unfolded or does not
		* support folding.
		*
		* The exact point when this status change happens during the folding
		* operation is device-specific.
		*/
		public static final long FOLDED = 1 << 2;

		/** @hide */
		@Retention(RetentionPolicy.SOURCE)
		@LongDef(prefix = {"DEVICE_STATE"}, value =
		{NORMAL,
		FOLDED })
		public @interface DeviceState {};

		private final HashMap<Long, Integer> mDeviceStateOrientationMap = new HashMap<>();

		/**
		* Create a new immutable DeviceStateOrientationMap instance.
		*
		* <p>This constructor takes over the array; do not write to the array afterwards.</p>
		*
		* @param elements
		* An array of elements describing the map
		*
		* @throws IllegalArgumentException
		* if the {@code elements} array length is invalid, not divisible by 2 or contains
		* invalid element values
		* @throws NullPointerException
		* if {@code elements} is {@code null}
		*
		* @hide
		*/
		public DeviceStateOrientationMap(final long[] elements) {
		mElements = Objects.requireNonNull(elements, "elements must not be null");
		if ((elements.length % 2) != 0) {
		throw new IllegalArgumentException("Device state orientation map length " +
		elements.length + " is not even!");
		}

		for (int i = 0; i < elements.length; i += 2) {
		if ((elements[i+1] % 90) != 0) {
		throw new IllegalArgumentException("Sensor orientation not divisible by 90: " +
		elements[i+1]);
		}

		mDeviceStateOrientationMap.put(elements[i], Math.toIntExact(elements[i + 1]));
		}
		}

		/**
		* Return the logical camera sensor orientation given a specific device fold state.
		*
		* @param deviceState Device fold state
		*
		* @return Valid {@link android.hardware.camera2.CameraCharacteristics#SENSOR_ORIENTATION} for
		* any supported device fold state
		*
		* @throws IllegalArgumentException if the given device state is invalid
		*/
		public int getSensorOrientation(@DeviceState long deviceState) {
		if (!mDeviceStateOrientationMap.containsKey(deviceState)) {
		throw new IllegalArgumentException("Invalid device state: " + deviceState);
		}

		return mDeviceStateOrientationMap.get(deviceState);
		}

		/**
		* Check if this DeviceStateOrientationMap is equal to another DeviceStateOrientationMap.
		*
		* <p>Two device state orientation maps are equal if and only if all of their elements are
		* {@link Object#equals equal}.</p>
		*
		* @return {@code true} if the objects were equal, {@code false} otherwise
		*/
		@Override
		public boolean equals(final Object obj) {
		if (obj == null) {
		return false;
		}
		if (this == obj) {
		return true;
		}
		if (obj instanceof DeviceStateOrientationMap) {
		final DeviceStateOrientationMap other = (DeviceStateOrientationMap) obj;
		return Arrays.equals(mElements, other.mElements);
		}
		return false;
		}

		/**
		* {@inheritDoc}
		*/
		@Override
		public int hashCode() {
		return HashCodeHelpers.hashCodeGeneric(mElements);
		}

		private final long[] mElements;
		}