@@ -18,6 +18,7 @@
import android.annotation.SuppressLint import android.os.Bundle+import android.os.Looper import android.util.Log import androidx.annotation.IntRange import androidx.annotation.RestrictTo@@ -287,7 +288,19 @@
iterationsPerRepeat = iterationsPerRepeat.coerceAtLeast(currentLoopsPerMeasurement) InMemoryTracing.beginSection(currentPhase.label)- val phaseProfilerResult = currentPhase.profiler?.start(traceUniqueName)+ val phaseProfilerResult = currentPhase.profiler?.run {+ val estimatedMethodTraceDurNs =+ warmupEstimatedIterationTimeNs * METHOD_TRACING_ESTIMATED_SLOWDOWN_FACTOR+ if (this == MethodTracing &&+ Looper.myLooper() == Looper.getMainLooper() &&+ estimatedMethodTraceDurNs > METHOD_TRACING_MAX_DURATION_NS) {+ Log.d(TAG, "Skipping method trace of estimated duration" ++ " ${estimatedMethodTraceDurNs / 1_000_000_000.0} sec to avoid ANR")+ null+ } else {+ start(traceUniqueName)+ }+ } if (phaseProfilerResult != null) { require(profilerResult == null) { "ProfileResult already set, only support one profiling phase"@@ -387,15 +400,30 @@
*/ private inline fun check(value: Boolean, lazyMessage: () -> String) { if (!value) {- ThreadPriority.resetBumpedThread()- if (phaseIndex >= 0 && phaseIndex <= phases.size) {- InMemoryTracing.endSection() // current phase cancelled, complete trace event- }+ cleanupBeforeThrow() throw IllegalStateException(lazyMessage()) } } /**+ * Ideally this would only be called when an exception is observed in measureRepeated, but to+ * account for java callers, we explicitly trigger before throwing as well.+ */+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)+ fun cleanupBeforeThrow() {+ if (phaseIndex >= 0 && phaseIndex <= phases.size) {+ Log.d(TAG, "aborting and cancelling benchmark")+ // current phase cancelled, complete current phase cleanup (trace event and profiling)+ InMemoryTracing.endSection()+ currentPhase.profiler?.stop()++ // for safety, set other state to done and do broader cleanup+ phaseIndex = phases.size+ afterBenchmark()+ }+ }++ /** * Internal loop control for benchmarks - will return true as long as there are more * measurements to perform. *@@ -549,6 +577,24 @@
internal const val REPEAT_COUNT_ALLOCATION = 5+ /**+ * Conservative estimate for how much method tracing slows down runtime+ * how much longer will `methodTrace {x()}` be than `x()`+ *+ * This is a conservative estimate, better version of this would account for OS/Art version+ *+ * Value derived from observed numbers on bramble API 31 (600-800x slowdown)+ */+ internal const val METHOD_TRACING_ESTIMATED_SLOWDOWN_FACTOR = 1000++ /**+ * Maximum duration to trace on main thread to avoid ANRs+ *+ * In practice, other types of tracing can be equally dangerous for ANRs,+ * but method tracing is the default tracing mode.+ */+ internal const val METHOD_TRACING_MAX_DURATION_NS = 4_000_000_000+ internal val DEFAULT_MEASUREMENT_DURATION_NS = TimeUnit.MILLISECONDS.toNanos(100) internal val SAMPLED_PROFILER_DURATION_NS = TimeUnit.SECONDS.toNanos(Arguments.profilerSampleDurationSeconds)
@@ -124,7 +124,7 @@
} public interface GattServerConnectFlow extends kotlinx.coroutines.flow.Flow {- method public void updateServices(java.util.List services);+ method public suspend Object? updateServices(java.util.List services, kotlin.coroutines.Continuation); } public final class GattServerConnectRequest {
@@ -124,7 +124,7 @@
} public interface GattServerConnectFlow extends kotlinx.coroutines.flow.Flow {- method public void updateServices(java.util.List services);+ method public suspend Object? updateServices(java.util.List services, kotlin.coroutines.Continuation); } public final class GattServerConnectRequest {
@@ -60,7 +60,6 @@
import android.content.ContentResolver; import android.content.ContentValues; import android.graphics.ImageFormat;-import android.graphics.Matrix; import android.graphics.Rect; import android.location.Location; import android.media.Image;@@ -112,10 +111,11 @@
import androidx.camera.core.impl.UseCaseConfig; import androidx.camera.core.impl.UseCaseConfigFactory; import androidx.camera.core.impl.utils.CameraOrientationUtil;-import androidx.camera.core.impl.utils.Exif;+import androidx.camera.core.impl.utils.CompareSizesByArea; import androidx.camera.core.impl.utils.executor.CameraXExecutors; import androidx.camera.core.impl.utils.futures.Futures; import androidx.camera.core.internal.IoConfig;+import androidx.camera.core.internal.SupportedOutputSizesSorter; import androidx.camera.core.internal.TargetConfig; import androidx.camera.core.internal.compat.quirk.SoftwareJpegEncodingPreferredQuirk; import androidx.camera.core.internal.compat.workaround.ExifRotationAvailability;@@ -128,21 +128,18 @@
import com.google.common.util.concurrent.ListenableFuture;-import java.io.ByteArrayInputStream; import java.io.File;-import java.io.IOException; import java.io.OutputStream; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;-import java.nio.ByteBuffer;+import java.util.Collections; import java.util.HashSet; import java.util.List;+import java.util.Map; import java.util.Objects; import java.util.Set; import java.util.UUID; import java.util.concurrent.Executor;-import java.util.concurrent.RejectedExecutionException;-import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; /**@@ -1092,6 +1089,12 @@
} }+ @Nullable+ private SessionProcessor getSessionProcessor() {+ CameraConfig cameraConfig = getCamera().getExtendedConfig();+ return cameraConfig.getSessionProcessor(null);+ }+ /** * {@inheritDoc} */@@ -1167,7 +1170,52 @@
// SessionConfig error callback and recreate children pipeline. mImagePipeline.close(); }- mImagePipeline = new ImagePipeline(config, resolution, getEffect(), isVirtualCamera);++ boolean isPostviewEnabled =+ getCurrentConfig().retrieveOption(OPTION_POSTVIEW_ENABLED, false);+ Size postViewSize = null;++ if (isPostviewEnabled) {+ SessionProcessor sessionProcessor = getSessionProcessor();+ if (sessionProcessor != null) {+ ResolutionSelector postviewSizeSelector =+ getCurrentConfig().retrieveOption(OPTION_POSTVIEW_RESOLUTION_SELECTOR,+ null);+ Map> map =+ sessionProcessor.getSupportedPostviewSize(resolution);+ List sizes = map.get(ImageFormat.JPEG);++ if (sizes != null) {+ if (postviewSizeSelector != null) {+ Collections.sort(sizes, new CompareSizesByArea(true));+ CameraInternal camera = getCamera();+ Rect sensorRect = camera.getCameraControlInternal().getSensorRect();+ CameraInfoInternal cameraInfo = camera.getCameraInfoInternal();+ Rational fullFov = new Rational(sensorRect.width(), sensorRect.height());+ List result =+ SupportedOutputSizesSorter+ .sortSupportedOutputSizesByResolutionSelector(+ postviewSizeSelector,+ sizes,+ null,+ getTargetRotation(),+ fullFov,+ cameraInfo.getSensorRotationDegrees(),+ cameraInfo.getLensFacing());+ if (result.isEmpty()) {+ throw new IllegalArgumentException("The postview ResolutionSelector "+ + "cannot select a valid size for the postview.");+ }+ postViewSize = result.get(0);+ } else {+ postViewSize = Collections.max(sizes, new CompareSizesByArea());+ }+ }+ }+ }++ mImagePipeline = new ImagePipeline(config, resolution, getEffect(), isVirtualCamera,+ postViewSize); if (mTakePictureManager == null) { // mTakePictureManager is reused when the Surface is reset.@@ -1449,6 +1497,53 @@
* error message and the throwable that caused it. */ void onError(@NonNull ImageCaptureException exception);++ /**+ * Callback to report the progress of the capture's processing.+ *+ *
To know in advanced if this callback will be invoked or not, check the
+ * capabilities by {@link #getImageCaptureCapabilities(CameraInfo)} and+ * {@link ImageCaptureCapabilities#isCaptureProcessProgressSupported()}.+ *+ * @param progress the progress ranging from 0 to 100.+ */+ @RestrictTo(Scope.LIBRARY_GROUP)+ default void onCaptureProcessProgressed(int progress) {+ }++ /**+ * Callback to notify that the postview image is available. The postview is intended to be+ * shown on UI before the long-processing capture is completed in order to provide a+ * better UX. The image format is {@link ImageFormat#JPEG}.+ *+ *
The postview is only available when the
+ * {@link ImageCaptureCapabilities#isPostviewSupported()} returns true for the specified+ * {@link CameraInfo} and applications must explicitly enable the postview using the+ * {@link Builder#setPostviewEnabled(boolean)}. Please note that if something goes wrong+ * when processing the postview, this callback method won't be invoked.+ *+ *
Please close the {@link ImageProxy} once you no longer need it. The default
+ * implementation of this method will close it in case apps don't implement the method.+ *+ *
The image is provided as captured by the underlying {@link ImageReader} without
+ * rotation applied. The value in {@code image.getImageInfo().getRotationDegrees()}+ * describes the magnitude of clockwise rotation, which if applied to the image will make+ * it match the currently configured target rotation.+ *+ *
For example, if the current target rotation is set to the display rotation,
+ * rotationDegrees is the rotation to apply to the image to match the display orientation.+ * A rotation of 90 degrees would mean rotating the image 90 degrees clockwise produces an+ * image that will match the display orientation.+ *+ *
See also {@link ImageCapture.Builder#setTargetRotation(int)} and
+ * {@link #setTargetRotation(int)}.+ *+ * @param image the postview {@link ImageProxy}+ */+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)+ default void onPostviewImageAvailable(@NonNull ImageProxy image) {+ image.close();+ } } /**@@ -1509,6 +1604,53 @@
*/ public void onError(@NonNull final ImageCaptureException exception) { }++ /**+ * Callback to report the progress of the capture's processing.+ *+ *
To know in advanced if this callback will be invoked or not, check the
+ * capabilities by {@link #getImageCaptureCapabilities(CameraInfo)} and+ * {@link ImageCaptureCapabilities#isCaptureProcessProgressSupported()}.+ *+ * @param progress the progress ranging from 0 to 100.+ */+ @RestrictTo(Scope.LIBRARY_GROUP)+ public void onCaptureProcessProgressed(int progress) {+ }++ /**+ * Callback to notify that the postview image is available. The postview is intended to be+ * shown on UI before the long-processing capture is completed in order to provide a+ * better UX. The image format is {@link ImageFormat#JPEG}.+ *+ *
The postview is only available when the
+ * {@link ImageCaptureCapabilities#isPostviewSupported()} returns true for the specified+ * {@link CameraInfo} and applications must explicitly enable the postview using the+ * {@link Builder#setPostviewEnabled(boolean)}. Please note that if something goes wrong+ * when processing the postview, this callback method won't be invoked.+ *+ *
Please close the {@link ImageProxy} once you no longer need it. The default
+ * implementation of this method will close it in case apps don't implement the method.+ *+ *
The image is provided as captured by the underlying {@link ImageReader} without
+ * rotation applied. The value in {@code image.getImageInfo().getRotationDegrees()}+ * describes the magnitude of clockwise rotation, which if applied to the image will make+ * it match the currently configured target rotation.+ *+ *
For example, if the current target rotation is set to the display rotation,
+ * rotationDegrees is the rotation to apply to the image to match the display orientation.+ * A rotation of 90 degrees would mean rotating the image 90 degrees clockwise produces an+ * image that will match the display orientation.+ *+ *
See also {@link ImageCapture.Builder#setTargetRotation(int)} and
+ * {@link #setTargetRotation(int)}.+ *+ * @param image the postview {@link ImageProxy}+ */+ @RestrictTo(Scope.LIBRARY_GROUP)+ public void onPostviewImageAvailable(@NonNull ImageProxy image) {+ image.close();+ } } /**@@ -1942,145 +2084,6 @@
} }- @VisibleForTesting- static class ImageCaptureRequest {- @RotationValue- final int mRotationDegrees;- @IntRange(from = 1, to = 100)- final int mJpegQuality;-- private final Rational mTargetRatio;- @NonNull- private final Executor mListenerExecutor;- @NonNull- private final OnImageCapturedCallback mCallback;-- AtomicBoolean mDispatched = new AtomicBoolean(false);-- private final Rect mViewPortCropRect;-- @NonNull- private final Matrix mSensorToBufferTransformMatrix;-- /**- * @param rotationDegrees The degrees to rotate the image buffer from sensor- * coordinates into the final output coordinate space.- * @param jpegQuality The requested output JPEG image compression- * quality. The value must- * be in range [1..100] which larger is higher quality.- * @param targetRatio The aspect ratio of the image in final output- * coordinate space.- * This must be a non-negative, non-zero value.- * @param viewPortCropRect The cropped rect of the field of view.- * @param sensorToBufferTransformMatrix The sensor to buffer transform matrix.- * @param executor The {@link Executor} which will be used for the- * listener.- * @param callback The {@link OnImageCapturedCallback} for the quest.- * @throws IllegalArgumentException If targetRatio is not a valid value.- */- ImageCaptureRequest(- @RotationValue int rotationDegrees,- @IntRange(from = 1, to = 100) int jpegQuality,- Rational targetRatio,- @Nullable Rect viewPortCropRect,- @NonNull Matrix sensorToBufferTransformMatrix,- @NonNull Executor executor,- @NonNull OnImageCapturedCallback callback) {- mRotationDegrees = rotationDegrees;- mJpegQuality = jpegQuality;- if (targetRatio != null) {- Preconditions.checkArgument(!targetRatio.isZero(), "Target ratio cannot be zero");- Preconditions.checkArgument(targetRatio.floatValue() > 0, "Target ratio must be "- + "positive");- }- mTargetRatio = targetRatio;- mViewPortCropRect = viewPortCropRect;- mSensorToBufferTransformMatrix = sensorToBufferTransformMatrix;- mListenerExecutor = executor;- mCallback = callback;- }-- void dispatchImage(final ImageProxy image) {- // Check to make sure image hasn't been already dispatched or error has been notified- if (!mDispatched.compareAndSet(false, true)) {- image.close();- return;- }-- Size dispatchResolution;- int dispatchRotationDegrees;-- // Retrieve the dimension and rotation values from the embedded EXIF data in the- // captured image only if those information is available.- if (EXIF_ROTATION_AVAILABILITY.shouldUseExifOrientation(image)) {- // JPEG needs to have rotation/crop based on the EXIF- try {- ImageProxy.PlaneProxy[] planes = image.getPlanes();- ByteBuffer buffer = planes[0].getBuffer();- Exif exif;-- buffer.rewind();-- byte[] data = new byte[buffer.capacity()];- buffer.get(data);- exif = Exif.createFromInputStream(new ByteArrayInputStream(data));- buffer.rewind();-- dispatchResolution = new Size(exif.getWidth(), exif.getHeight());- dispatchRotationDegrees = exif.getRotation();- } catch (IOException e) {- notifyCallbackError(ERROR_FILE_IO, "Unable to parse JPEG exif", e);- image.close();- return;- }- } else {- // All other formats take the rotation based simply on the target rotation- dispatchResolution = new Size(image.getWidth(), image.getHeight());- dispatchRotationDegrees = mRotationDegrees;- }-- // Construct the ImageProxy with the updated rotation & crop for the output- ImageInfo imageInfo = ImmutableImageInfo.create(- image.getImageInfo().getTagBundle(),- image.getImageInfo().getTimestamp(),- dispatchRotationDegrees,- mSensorToBufferTransformMatrix);-- final ImageProxy dispatchedImageProxy = new SettableImageProxy(image,- dispatchResolution, imageInfo);-- // Update the crop rect aspect ratio after it has been rotated into the buffer- // orientation- Rect cropRect = computeDispatchCropRect(mViewPortCropRect, mTargetRatio,- mRotationDegrees, dispatchResolution, dispatchRotationDegrees);- dispatchedImageProxy.setCropRect(cropRect);-- try {- mListenerExecutor.execute(() -> mCallback.onCaptureSuccess(dispatchedImageProxy));- } catch (RejectedExecutionException e) {- Logger.e(TAG, "Unable to post to the supplied executor.");-- // Unable to execute on the supplied executor, close the image.- image.close();- }- }-- void notifyCallbackError(final @ImageCaptureError int imageCaptureError,- final String message, final Throwable cause) {- // Check to make sure image hasn't been already dispatched or error has been notified- if (!mDispatched.compareAndSet(false, true)) {- return;- }-- try {- mListenerExecutor.execute(() -> mCallback.onError(- new ImageCaptureException(imageCaptureError, message, cause)));- } catch (RejectedExecutionException e) {- Logger.e(TAG, "Unable to post to the supplied executor.");- }- }- }- /** Builder for an {@link ImageCapture}. */ @SuppressWarnings({"ObjectToString", "unused"}) public static final class Builder implements
@@ -151,6 +151,27 @@
mTakePictureRequest.onResult(imageProxy); }+ @Override+ public void onCaptureProcessProgressed(int progress) {+ checkMainThread();+ if (mIsAborted) {+ return;+ }++ mTakePictureRequest.onCaptureProcessProgressed(progress);+ }++ @Override+ public void onPostviewImageAvailable(@NonNull ImageProxy imageProxy) {+ checkMainThread();+ if (mIsAborted) {+ // Do not deliver result if the request has been aborted.+ return;+ }++ mTakePictureRequest.onPostviewImageAvailable(imageProxy);+ }+ @MainThread @Override public void onProcessFailure(@NonNull ImageCaptureException imageCaptureException) {
@@ -36,6 +36,13 @@
void onCaptureStarted(); /**+ * Invoked when there is some progress in the processing stage.+ *+ * @param progress the progress ranging from 0 to 100.+ */+ void onCaptureProcessProgressed(int progress);++ /** * Invoked when the capture is complete. * *
Once invoked, {@link TakePictureManager} can submit the next request to camera.
@@ -63,6 +70,11 @@
void onFinalResult(@NonNull ImageProxy imageProxy); /**+ * Invoked when the postview image is available.+ */+ void onPostviewImageAvailable(@NonNull ImageProxy imageProxy);++ /** * Invoked when camera fails to return the image. * *
After invoked, the {@link TakePictureCallback} will never be invoked again.
@@ -59,4 +59,11 @@
*/ public void onCaptureCancelled() { }++ /**+ * This method is called to notify the client of the progress in the processing stage.+ */+ public void onCaptureProcessProgressed(int progress) {++ } }
@@ -0,0 +1,67 @@
+/*+ * Copyright 2023 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 androidx.camera.core.impl;++import androidx.annotation.NonNull;+import androidx.annotation.Nullable;+import androidx.annotation.RequiresApi;++import com.google.auto.value.AutoValue;++/**+ * The configuration for all the output surfaces of the SessionProcessor.+ */+@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java+@AutoValue+public abstract class OutputSurfaceConfiguration {+ /**+ * Creates an OutputSurface instance.+ */+ @NonNull+ public static OutputSurfaceConfiguration create(+ @NonNull OutputSurface previewOutputSurface,+ @NonNull OutputSurface imageCaptureOutputSurface,+ @Nullable OutputSurface imageAnalysisOutputSurface,+ @Nullable OutputSurface postviewOutputSurface) {+ return new AutoValue_OutputSurfaceConfiguration(+ previewOutputSurface, imageCaptureOutputSurface,+ imageAnalysisOutputSurface, postviewOutputSurface);+ }+ /**+ * gets the preview {@link OutputSurface}.+ */+ @NonNull+ public abstract OutputSurface getPreviewOutputSurface();++ /**+ * gets the still capture {@link OutputSurface}.+ */+ @NonNull+ public abstract OutputSurface getImageCaptureOutputSurface();++ /**+ * gets the image analysis {@link OutputSurface}.+ */+ @Nullable+ public abstract OutputSurface getImageAnalysisOutputSurface();++ /**+ * gets the postview {@link OutputSurface}.+ */+ @Nullable+ public abstract OutputSurface getPostviewOutputSurface();+}
@@ -55,6 +55,8 @@
public static final int DEFAULT_SESSION_TYPE = SessionConfiguration.SESSION_REGULAR; /** The set of {@link OutputConfig} that data from the camera will be put into. */ private final List mOutputConfigs;+ /** The {@link OutputConfig} for the postview. */+ private final OutputConfig mPostviewOutputConfig; /** The state callback for a {@link CameraDevice}. */ private final List mDeviceStateCallbacks; /** The state callback for a {@link CameraCaptureSession}. */@@ -213,7 +215,8 @@
List errorListeners, CaptureConfig repeatingCaptureConfig, @Nullable InputConfiguration inputConfiguration,- int sessionType) {+ int sessionType,+ @Nullable OutputConfig postviewOutputConfig) { mOutputConfigs = outputConfigs; mDeviceStateCallbacks = Collections.unmodifiableList(deviceStateCallbacks); mSessionStateCallbacks = Collections.unmodifiableList(sessionStateCallbacks);@@ -223,6 +226,7 @@
mRepeatingCaptureConfig = repeatingCaptureConfig; mInputConfiguration = inputConfiguration; mSessionType = sessionType;+ mPostviewOutputConfig = postviewOutputConfig; } /** Returns an instance of a session configuration with minimal configurations. */@@ -236,7 +240,8 @@
new ArrayList<>(0), new CaptureConfig.Builder().build(), /* inputConfiguration */ null,- DEFAULT_SESSION_TYPE);+ DEFAULT_SESSION_TYPE,+ /* postviewOutputConfig */ null); } @Nullable@@ -266,6 +271,11 @@
return mOutputConfigs; }+ @Nullable+ public OutputConfig getPostviewOutputConfig() {+ return mPostviewOutputConfig;+ }+ @NonNull public Config getImplementationOptions() { return mRepeatingCaptureConfig.getImplementationOptions();@@ -378,6 +388,8 @@
@Nullable InputConfiguration mInputConfiguration; int mSessionType = DEFAULT_SESSION_TYPE;+ @Nullable+ OutputConfig mPostviewOutputConfig; } /**@@ -693,6 +705,15 @@
return this; }+ /**+ * Sets the postview surface.+ */+ @NonNull+ public Builder setPostviewSurface(@NonNull DeferrableSurface surface) {+ mPostviewOutputConfig = OutputConfig.builder(surface).build();+ return this;+ }+ /** Remove a surface from the set which the session repeatedly writes to. */ @NonNull public Builder removeSurface(@NonNull DeferrableSurface surface) {@@ -747,7 +768,8 @@
new ArrayList<>(mErrorListeners), mCaptureConfigBuilder.build(), mInputConfiguration,- mSessionType);+ mSessionType,+ mPostviewOutputConfig); } }@@ -849,6 +871,19 @@
} }+ if (sessionConfig.mPostviewOutputConfig != null) {+ if (mPostviewOutputConfig != sessionConfig.mPostviewOutputConfig+ && mPostviewOutputConfig != null) {+ String errorMessage =+ "Invalid configuration due to that two different postview output "+ + "configs are set";+ Logger.d(TAG, errorMessage);+ mValid = false;+ } else {+ mPostviewOutputConfig = sessionConfig.mPostviewOutputConfig;+ }+ }+ // The conflicting of options is handled in addImplementationOptions where it could // throw an IllegalArgumentException if the conflict cannot be resolved. mCaptureConfigBuilder.addImplementationOptions(@@ -928,7 +963,8 @@
new ArrayList<>(mErrorListeners), mCaptureConfigBuilder.build(), mInputConfiguration,- mSessionType);+ mSessionType,+ mPostviewOutputConfig); } private int selectTemplateType(int type1, int type2) {
@@ -19,6 +19,7 @@
import android.hardware.camera2.CaptureResult; import android.media.ImageReader; import android.util.Pair;+import android.util.Size; import androidx.annotation.NonNull; import androidx.annotation.Nullable;@@ -26,6 +27,7 @@
import androidx.camera.core.CameraInfo; import java.util.Collections;+import java.util.List; import java.util.Map; import java.util.Set;@@ -54,19 +56,14 @@
* SessionProcessor is responsible to write the output to this given output surfaces. * * @param cameraInfo cameraInfo for querying the camera info- * @param previewSurfaceConfig output surface for preview. This is mandatory.- * @param imageCaptureSurfaceConfig output surface for image capture. This is mandatory.- * @param imageAnalysisSurfaceConfig output surface for image analysis. This is optional.- * Passing null if image analysis output is not needed.+ * @param outputSurfaceConfig output surface configuration for preview, image capture,+ * image analysis and the postview. * @return a {@link SessionConfig} that contains the surfaces and the session parameters and * should be used to configure the camera session. */ @NonNull- SessionConfig initSession(- @NonNull CameraInfo cameraInfo,- @NonNull OutputSurface previewSurfaceConfig,- @NonNull OutputSurface imageCaptureSurfaceConfig,- @Nullable OutputSurface imageAnalysisSurfaceConfig);+ SessionConfig initSession(@NonNull CameraInfo cameraInfo,+ @NonNull OutputSurfaceConfiguration outputSurfaceConfig); /** * De-initializes the session. This is called after the camera session is closed.@@ -111,11 +108,11 @@
* Requests the SessionProcessor to start the still image capture. The capture task can only * perform one at a time. *+ * @param postviewEnabled if postview is enabled or not. * @param callback callback to notify the status. * @return the id of the capture sequence. */- int startCapture(- @NonNull CaptureCallback callback);+ int startCapture(boolean postviewEnabled, @NonNull CaptureCallback callback); /** * Aborts the pending capture.@@ -130,6 +127,15 @@
} /**+ * Returns supported output format/size map for postview image. The API is provided+ * for camera-core to query the supported postview sizes from SessionProcessor.+ */+ @NonNull+ default Map> getSupportedPostviewSize(@NonNull Size captureSize) {+ return Collections.emptyMap();+ }++ /** * Returns the supported camera operations when the SessionProcessor is enabled. */ @NonNull@@ -241,5 +247,19 @@
*/ default void onCaptureCompleted(long timestamp, int captureSequenceId, @NonNull Map result) {}++ /**+ * Capture progress callback that needs to be called when the process capture is+ * ongoing and includes the estimated progress of the processing.+ *+ *
Extensions must ensure that they always call this callback with monotonically
+ * increasing values.+ *+ *
Extensions are allowed to trigger this callback multiple times but at the minimum the
+ * callback is expected to be called once when processing is done with value 100.+ *+ * @param progress Value between 0 and 100.+ */+ default void onCaptureProcessProgressed(int progress) {} } }
@@ -66,13 +66,12 @@
* */ @RequiresApi(21)-class SupportedOutputSizesSorter {+public class SupportedOutputSizesSorter { private static final String TAG = "SupportedOutputSizesCollector"; private final CameraInfoInternal mCameraInfoInternal; private final int mSensorOrientation; private final int mLensFacing; private final Rational mFullFovRatio;- private final boolean mIsSensorLandscapeResolution; private final SupportedOutputSizesSorterLegacy mSupportedOutputSizesSorterLegacy; SupportedOutputSizesSorter(@NonNull CameraInfoInternal cameraInfoInternal,@@ -83,9 +82,6 @@
mFullFovRatio = activeArraySize != null ? calculateFullFovRatioFromActiveArraySize( activeArraySize) : calculateFullFovRatioFromSupportedOutputSizes( mCameraInfoInternal);- // Determines the sensor resolution orientation info by the full FOV ratio.- mIsSensorLandscapeResolution = mFullFovRatio != null ? mFullFovRatio.getNumerator()- >= mFullFovRatio.getDenominator() : true; mSupportedOutputSizesSorterLegacy = new SupportedOutputSizesSorterLegacy(cameraInfoInternal, mFullFovRatio); }@@ -134,42 +130,47 @@
} ResolutionSelector resolutionSelector = imageOutputConfig.getResolutionSelector(null);+ List> customResolutions =+ imageOutputConfig.getSupportedResolutions(null);+ List candidateSizes = getResolutionCandidateList(customResolutions,+ useCaseConfig.getInputFormat()); if (resolutionSelector == null) { return mSupportedOutputSizesSorterLegacy.sortSupportedOutputSizes(- getResolutionCandidateList(useCaseConfig), useCaseConfig);+ candidateSizes, useCaseConfig); } else {- return sortSupportedOutputSizesByResolutionSelector(useCaseConfig);+ Size maxResolution = ((ImageOutputConfig) useCaseConfig).getMaxResolution(null);+ int targetRotation = imageOutputConfig.getTargetRotation(Surface.ROTATION_0);+ // Applies the high resolution settings onto the resolution candidate list.+ if (!useCaseConfig.isHigResolutionDisabled(false)) {+ candidateSizes = applyHighResolutionSettings(candidateSizes,+ resolutionSelector, useCaseConfig.getInputFormat());+ }+ return sortSupportedOutputSizesByResolutionSelector(+ imageOutputConfig.getResolutionSelector(),+ candidateSizes,+ maxResolution,+ targetRotation,+ mFullFovRatio,+ mSensorOrientation,+ mLensFacing); } }- /**- * Retrieves the customized supported resolutions from the use case config.- *- *
In some cases, the use case might not be able to use all the supported output sizes
- * retrieved from the stream configuration map. For example, extensions is enabled. These- * sizes can be set in the use case config by- * {@link ImageOutputConfig.Builder#setSupportedResolutions(List)}. SupportedOutputSizesSorter- * should use the customized supported resolutions to run the sort/filter logic if it is set.- */ @Nullable- private List getCustomizedSupportedResolutionsFromConfig(int imageFormat,- @NonNull ImageOutputConfig config) {+ private List getSizeListByFormat(+ @Nullable List> resolutionsPairList,+ int imageFormat) { Size[] outputSizes = null;- // Try to retrieve customized supported resolutions from config.- List> formatResolutionsPairList =- config.getSupportedResolutions(null);-- if (formatResolutionsPairList != null) {- for (Pair formatResolutionPair : formatResolutionsPairList) {+ if (resolutionsPairList != null) {+ for (Pair formatResolutionPair : resolutionsPairList) { if (formatResolutionPair.first == imageFormat) { outputSizes = formatResolutionPair.second; break; } } }- return outputSizes == null ? null : Arrays.asList(outputSizes); }@@ -177,10 +178,6 @@
* Sorts the resolution candidate list according to the ResolutionSelector API logic. * * - *
Collects the output sizes
- *
- *
Applies the high resolution settings
- * *
Applies the aspect ratio strategy
*
*
Applies the aspect ratio strategy fallback rule
@@ -191,35 +188,38 @@
* *
Applies the resolution filter
* - *+ * @param resolutionSelector the ResolutionSelector used to sort the candidate+ * sizes.+ * @param candidateSizes the candidate sizes after the high resolution processing, which+ * will be sorted by the rule of ResolutionSelector.+ * @param maxResolution the max resolutions which sizes larger than it will be removed+ * from candidate sizes.+ * @param targetRotation the target rotation to calculate the rotation degrees to the+ * {@link ResolutionFilter}.+ * @param fullFovRatio the full FOV's aspect ratio.+ * @param sensorOrientation the sensor orientation of the current camera.+ * @param lensFacing the lens facing of the current camera * @return a size list which has been filtered and sorted by the specified resolution * selector settings. * @throws IllegalArgumentException if the specified resolution filter returns any size which * is not included in the provided supported size list. */ @NonNull- private List sortSupportedOutputSizesByResolutionSelector(- @NonNull UseCaseConfig useCaseConfig) {- ResolutionSelector resolutionSelector =- ((ImageOutputConfig) useCaseConfig).getResolutionSelector();-- // Retrieves the normal supported output sizes.- List resolutionCandidateList = getResolutionCandidateList(useCaseConfig);-- // Applies the high resolution settings onto the resolution candidate list.- if (!useCaseConfig.isHigResolutionDisabled(false)) {- resolutionCandidateList = applyHighResolutionSettings(resolutionCandidateList,- resolutionSelector, useCaseConfig.getInputFormat());- }+ public static List sortSupportedOutputSizesByResolutionSelector(+ @NonNull ResolutionSelector resolutionSelector,+ @NonNull List candidateSizes,+ @Nullable Size maxResolution,+ int targetRotation,+ @NonNull Rational fullFovRatio,+ int sensorOrientation,+ int lensFacing) { // Applies the aspect ratio strategy onto the resolution candidate list. LinkedHashMap> aspectRatioSizeListMap =- applyAspectRatioStrategy(resolutionCandidateList,- resolutionSelector.getAspectRatioStrategy());-+ applyAspectRatioStrategy(candidateSizes,+ resolutionSelector.getAspectRatioStrategy(), fullFovRatio); // Applies the max resolution setting- Size maxResolution = ((ImageOutputConfig) useCaseConfig).getMaxResolution(null); if (maxResolution != null) { applyMaxResolutionRestriction(aspectRatioSizeListMap, maxResolution); }@@ -241,7 +241,7 @@
// Applies the resolution filter onto the resolution candidate list. return applyResolutionFilter(resultList, resolutionSelector.getResolutionFilter(),- ((ImageOutputConfig) useCaseConfig).getTargetRotation(Surface.ROTATION_0));+ targetRotation, sensorOrientation, lensFacing); } /**@@ -253,12 +253,10 @@
* @return the resolution candidate list sorted in descending order. */ @NonNull- private List getResolutionCandidateList(@NonNull UseCaseConfig useCaseConfig) {- int imageFormat = useCaseConfig.getInputFormat();- ImageOutputConfig imageOutputConfig = (ImageOutputConfig) useCaseConfig;+ private List getResolutionCandidateList(+ @Nullable List> customResolutions, int imageFormat) { // Tries to get the custom supported resolutions list if it is set- List resolutionCandidateList = getCustomizedSupportedResolutionsFromConfig(- imageFormat, imageOutputConfig);+ List resolutionCandidateList = getSizeListByFormat(customResolutions, imageFormat); // Tries to get the supported output sizes from the CameraInfoInternal if both custom // ordered and supported resolutions lists are not set.@@ -319,15 +317,17 @@
* is applied and is sorted against the preferred aspect ratio. */ @NonNull- private LinkedHashMap> applyAspectRatioStrategy(+ private static LinkedHashMap> applyAspectRatioStrategy( @NonNull List resolutionCandidateList,- @NonNull AspectRatioStrategy aspectRatioStrategy) {+ @NonNull AspectRatioStrategy aspectRatioStrategy,+ Rational fullFovRatio) { // Group output sizes by aspect ratio. Map> aspectRatioSizeListMap = groupSizesByAspectRatio(resolutionCandidateList); // Applies the aspect ratio fallback rule- return applyAspectRatioStrategyFallbackRule(aspectRatioSizeListMap, aspectRatioStrategy);+ return applyAspectRatioStrategyFallbackRule(+ aspectRatioSizeListMap, aspectRatioStrategy, fullFovRatio); } /**@@ -339,17 +339,21 @@
* @return an aspect ratio to size list linked hash map which the aspect ratio fallback rule * is applied and is sorted against the preferred aspect ratio. */- private LinkedHashMap> applyAspectRatioStrategyFallbackRule(+ private static LinkedHashMap> applyAspectRatioStrategyFallbackRule( @NonNull Map> sizeGroupsMap,- @NonNull AspectRatioStrategy aspectRatioStrategy) {+ @NonNull AspectRatioStrategy aspectRatioStrategy,+ Rational fullFovRatio) {+ // Determines the sensor resolution orientation info by the full FOV ratio.+ boolean isSensorLandscapeResolution = fullFovRatio != null ? fullFovRatio.getNumerator()+ >= fullFovRatio.getDenominator() : true; Rational aspectRatio = getTargetAspectRatioRationalValue(- aspectRatioStrategy.getPreferredAspectRatio(), mIsSensorLandscapeResolution);+ aspectRatioStrategy.getPreferredAspectRatio(), isSensorLandscapeResolution); // Remove items of all other aspect ratios if the fallback rule is AspectRatioStrategy // .FALLBACK_RULE_NONE if (aspectRatioStrategy.getFallbackRule() == AspectRatioStrategy.FALLBACK_RULE_NONE) { Rational preferredAspectRatio = getTargetAspectRatioRationalValue(- aspectRatioStrategy.getPreferredAspectRatio(), mIsSensorLandscapeResolution);+ aspectRatioStrategy.getPreferredAspectRatio(), isSensorLandscapeResolution); for (Rational ratio : new ArrayList<>(sizeGroupsMap.keySet())) { if (!ratio.equals(preferredAspectRatio)) { sizeGroupsMap.remove(ratio);@@ -361,7 +365,7 @@
List aspectRatios = new ArrayList<>(sizeGroupsMap.keySet()); Collections.sort(aspectRatios, new AspectRatioUtil.CompareAspectRatiosByMappingAreaInFullFovAspectRatioSpace(- aspectRatio, mFullFovRatio));+ aspectRatio, fullFovRatio)); // Stores the size groups into LinkedHashMap to keep the order LinkedHashMap> sortedAspectRatioSizeListMap = new LinkedHashMap<>();@@ -481,9 +485,11 @@
* is not included in the provided supported size list. */ @NonNull- private List applyResolutionFilter(@NonNull List sizeList,+ private static List applyResolutionFilter(@NonNull List sizeList, @Nullable ResolutionFilter resolutionFilter,- @ImageOutputConfig.RotationValue int targetRotation) {+ @ImageOutputConfig.RotationValue int targetRotation,+ int sensorOrientation,+ int lensFacing) { if (resolutionFilter == null) { return sizeList; }@@ -494,8 +500,8 @@
targetRotation); int rotationDegrees = CameraOrientationUtil.getRelativeImageRotation(destRotationDegrees,- mSensorOrientation,- mLensFacing == CameraSelector.LENS_FACING_BACK);+ sensorOrientation,+ lensFacing == CameraSelector.LENS_FACING_BACK); List filteredResultList = resolutionFilter.filter(new ArrayList<>(sizeList), rotationDegrees); if (sizeList.containsAll(filteredResultList)) {
@@ -27,7 +27,7 @@
public class ClientVersion { // Current version of vendor library implementation that the CameraX extension supports. This // needs to be increased along with the version of vendor library interface.- private static ClientVersion sCurrent = new ClientVersion("1.3.0");+ private static ClientVersion sCurrent = new ClientVersion("1.4.0"); @NonNull public static ClientVersion getCurrentVersion() {
@@ -0,0 +1,66 @@
+/*+ * Copyright 2023 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 androidx.camera.testing.impl.fakes++import androidx.annotation.RequiresApi+import androidx.annotation.RestrictTo+import androidx.camera.core.impl.CameraConfig+import androidx.camera.core.impl.Config+import androidx.camera.core.impl.Identifier+import androidx.camera.core.impl.OptionsBundle+import androidx.camera.core.impl.SessionProcessor+import androidx.camera.core.impl.UseCaseConfigFactory++@RequiresApi(21) // TODO(b/200306659): Remove and replace with annotation on package-info.java+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)+class FakeCameraConfig(+ private val sessionProcessor: SessionProcessor? = null,+ private val postviewSupported: Boolean = false,+ private val captureProcessProgressSupported: Boolean = false+) : CameraConfig {+ private val mUseCaseConfigFactory =+ UseCaseConfigFactory { _, _ -> null }+ private val mIdentifier = Identifier.create(Any())++ override fun getUseCaseConfigFactory(): UseCaseConfigFactory {+ return mUseCaseConfigFactory+ }++ override fun isPostviewSupported(): Boolean {+ return postviewSupported+ }++ override fun isCaptureProcessProgressSupported(): Boolean {+ return captureProcessProgressSupported+ }++ override fun getCompatibilityId(): Identifier {+ return mIdentifier+ }++ override fun getConfig(): Config {+ return OptionsBundle.emptyBundle()+ }++ override fun getSessionProcessor(valueIfMissing: SessionProcessor?): SessionProcessor? {+ return sessionProcessor ?: valueIfMissing+ }++ override fun getSessionProcessor(): SessionProcessor {+ return sessionProcessor!!+ }+}
@@ -854,6 +854,19 @@
package androidx.car.app.mediaextensions {+ public final class MediaBrowserExtras {+ field public static final String KEY_HINT_HOST_PACKAGE_NAME = "androidx.car.app.mediaextensions.KEY_HINT_HOST_PACKAGE_NAME";+ field public static final String KEY_HINT_VIEW_HEIGHT_PIXELS = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_HEIGHT_PIXELS";+ field public static final String KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED";+ field public static final String KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_WIDTH_PIXELS = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_WIDTH_PIXELS";+ field public static final String KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED = "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED";+ field public static final String KEY_ROOT_HINT_MEDIA_SESSION_API = "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MEDIA_SESSION_API";+ }+ public final class MetadataExtras { field public static final String KEY_CONTENT_FORMAT_TINTABLE_LARGE_ICON_URI = "androidx.car.app.mediaextensions.KEY_CONTENT_FORMAT_TINTABLE_LARGE_ICON_URI"; field public static final String KEY_CONTENT_FORMAT_TINTABLE_SMALL_ICON_URI = "androidx.car.app.mediaextensions.KEY_CONTENT_FORMAT_TINTABLE_SMALL_ICON_URI";
@@ -854,6 +854,19 @@
package androidx.car.app.mediaextensions {+ public final class MediaBrowserExtras {+ field public static final String KEY_HINT_HOST_PACKAGE_NAME = "androidx.car.app.mediaextensions.KEY_HINT_HOST_PACKAGE_NAME";+ field public static final String KEY_HINT_VIEW_HEIGHT_PIXELS = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_HEIGHT_PIXELS";+ field public static final String KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED";+ field public static final String KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW";+ field public static final String KEY_HINT_VIEW_WIDTH_PIXELS = "androidx.car.app.mediaextensions.KEY_HINT_VIEW_WIDTH_PIXELS";+ field public static final String KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED = "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED";+ field public static final String KEY_ROOT_HINT_MEDIA_SESSION_API = "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MEDIA_SESSION_API";+ }+ public final class MetadataExtras { field public static final String KEY_CONTENT_FORMAT_TINTABLE_LARGE_ICON_URI = "androidx.car.app.mediaextensions.KEY_CONTENT_FORMAT_TINTABLE_LARGE_ICON_URI"; field public static final String KEY_CONTENT_FORMAT_TINTABLE_SMALL_ICON_URI = "androidx.car.app.mediaextensions.KEY_CONTENT_FORMAT_TINTABLE_SMALL_ICON_URI";
@@ -0,0 +1,165 @@
+/*+ * Copyright 2023 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 androidx.car.app.mediaextensions;++import android.os.Bundle;++import androidx.media.MediaBrowserServiceCompat;++/**+ * Defines constants for extra keys in {@link androidx.media.MediaBrowserServiceCompat}.+ *+ *
Media apps can use these extras to enhance their analytics.
+ *+ *
They can also take them into account to decide how many media items to return. For example,
+ * providing a number of recommendation items that is a multiple of the maximum number of items+ * shown in a grid row will use the screen space more efficiently (avoiding blanks).+ */+public final class MediaBrowserExtras {++ // Do not instantiate+ private MediaBrowserExtras() {+ }++ /**+ * {@link Bundle} key used in the rootHints bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onGetRoot(String, int, Bundle)} to indicate+ * which version of the media api is used by the caller+ *+ *
TYPE: int - the media api level (1, 2, 3).
+ */+ public static final String KEY_ROOT_HINT_MEDIA_SESSION_API =+ "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MEDIA_SESSION_API";++ /**+ * {@link Bundle} key used in the rootHints bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onGetRoot(String, int, Bundle)} to indicate+ * the maximum number of queue items reachable under driving restrictions. This sublist is+ * centered around the currently playing item.+ *+ *
TYPE: int - the maximum number of queue items when restricted, -1 when unlimited
+ */+ public static final String KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED =+ "androidx.car.app.mediaextensions.KEY_ROOT_HINT_MAX_QUEUE_ITEMS_WHILE_RESTRICTED";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate the package name reported by the caller.+ *+ *
TYPE: String - the unverified caller's package name
+ */+ public static final String KEY_HINT_HOST_PACKAGE_NAME =+ "androidx.car.app.mediaextensions.KEY_HINT_HOST_PACKAGE_NAME";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate the width of the view that will show the+ * returned media items.+ *+ *
TYPE: int - width of the view in pixels
+ */+ public static final String KEY_HINT_VIEW_WIDTH_PIXELS =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_WIDTH_PIXELS";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate the height of the view that will show the+ * returned media items.+ *+ *
TYPE: int - height of the view in pixels
+ */+ public static final String KEY_HINT_VIEW_HEIGHT_PIXELS =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_HEIGHT_PIXELS";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate the maximum number of returned items+ * reachable under driving restrictions.+ *+ *
TYPE: int - the maximum number of items when restricted, -1 when unlimited
+ */+ public static final String KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_ITEMS_WHILE_RESTRICTED";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate how many media items tagged with+ * {@link androidx.media.utils.MediaConstants#DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM}+ * are displayed on a single row.+ *+ *
TYPE: int - maximum number of list items per row.
+ */+ public static final String KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_LIST_ITEMS_COUNT_PER_ROW";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate how many media items tagged with+ * {@link androidx.media.utils.MediaConstants#DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM}+ * are displayed on a single row.+ *+ *
TYPE: int - maximum number of grid items per row.
+ */+ public static final String KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_GRID_ITEMS_COUNT_PER_ROW";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate how many media items tagged with+ * {@link androidx.media.utils.MediaConstants#DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_LIST_ITEM}+ * are displayed on a single row.+ *+ *
TYPE: int - maximum number of category list items per row.
+ */+ public static final String KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_LIST_ITEMS_COUNT_PER_ROW";++ /**+ * {@link Bundle} key used in the options bundle passed to+ * {@link androidx.media.MediaBrowserServiceCompat#onLoadChildren(String,+ * MediaBrowserServiceCompat.Result, Bundle)} or to+ * {@link androidx.media.MediaBrowserServiceCompat#onSearch(String, Bundle,+ * MediaBrowserServiceCompat.Result)} to indicate how many media items tagged with+ * {@link androidx.media.utils.MediaConstants#DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_GRID_ITEM}+ * are displayed on a single row.+ *+ *
TYPE: int - maximum number of category grid items per row.
+ */+ public static final String KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW =+ "androidx.car.app.mediaextensions.KEY_HINT_VIEW_MAX_CATEGORY_GRID_ITEMS_COUNT_PER_ROW";+}
@@ -0,0 +1,381 @@
+/*+ * Copyright 2023 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 androidx.compose.animation.core+import kotlin.math.max+import kotlin.math.min++// TODO: We should probably move this to androidx.collection++/**+ * Interval in an [IntervalTree]. The interval is defined between a [start] and an [end]+ * coordinates, whose meanings are defined by the caller. An interval can also hold+ * arbitrary [data] to be used to looking at the result of queries with+ * [IntervalTree.findOverlaps].+ */+internal class Interval(val start: Float, val end: Float, val data: T? = null) {+ /**+ * Returns trues if this interval overlaps with another interval.+ */+ fun overlaps(other: Interval) = start <= other.end && end >= other.start++ /**+ * Returns trues if this interval overlaps with the interval defined by [start]+ * and [end]. [start] must be less than or equal to [end].+ */+ fun overlaps(start: Float, end: Float) = this.start <= end && this.end >= start++ /**+ * Returns true if this interval contains [value].+ */+ operator fun contains(value: Float) = value in start..end++ override fun equals(other: Any?): Boolean {+ if (this === other) return true+ if (other == null || this::class != other::class) return false++ other as Interval<*>++ if (start != other.start) return false+ if (end != other.end) return false+ if (data != other.data) return false++ return true+ }++ override fun hashCode(): Int {+ var result = start.hashCode()+ result = 31 * result + end.hashCode()+ result = 31 * result + (data?.hashCode() ?: 0)+ return result+ }++ override fun toString(): String {+ return "Interval(start=$start, end=$end, data=$data)"+ }+}++internal val EmptyInterval: Interval = Interval(Float.MAX_VALUE, Float.MIN_VALUE, null)++/**+ * An interval tree holds a list of intervals and allows for fast queries of intervals+ * that overlap any given interval. This can be used for instance to perform fast spatial+ * queries like finding all the segments in a path that overlap with a given vertical+ * interval.+ */+internal class IntervalTree {+ // Note: this interval tree is implemented as a binary red/black tree that gets+ // re-balanced on updates. There's nothing notable about this particular data+ // structure beyond what can be found in various descriptions of binary search+ // trees and red/black trees++ private val terminator = Node(+ Interval(Float.MAX_VALUE, Float.MIN_VALUE, null),+ TreeColor.Black+ )+ private var root = terminator++ /**+ * Clears this tree and prepares it for reuse. After calling [clear], any call to+ * [findOverlaps] returns false.+ */+ fun clear() {+ root = terminator+ }++ /**+ * Finds the first interval that overlaps with the specified [interval]. If no overlap can+ * be found, return [EmptyInterval].+ */+ fun findFirstOverlap(interval: ClosedFloatingPointRange) =+ findFirstOverlap(interval.start, interval.endInclusive)++ /**+ * Finds the first interval that overlaps with the interval defined by [start] and [end].+ * If no overlap can be found, return [EmptyInterval]. [start] *must* be lesser than or+ * equal to [end].+ */+ fun findFirstOverlap(+ start: Float,+ end: Float = start+ ): Interval {+ if (root !== terminator) {+ return findFirstOverlap(root, start, end)+ }+ @Suppress("UNCHECKED_CAST")+ return EmptyInterval as Interval+ }++ private fun findFirstOverlap(+ node: Node,+ start: Float,+ end: Float+ ): Interval {+ if (node.interval.overlaps(start, end)) return node.interval+ if (node.left !== terminator && node.left.max >= start) {+ return findFirstOverlap(node.left, start, end)+ }+ if (node.right !== terminator && node.right.min <= end) {+ return findFirstOverlap(node.right, start, end)+ }+ @Suppress("UNCHECKED_CAST")+ return EmptyInterval as Interval+ }++ /**+ * Finds all the intervals that overlap with the specified [interval]. If [results]+ * is specified, [results] is returned, otherwise a new [MutableList] is returned.+ */+ fun findOverlaps(+ interval: ClosedFloatingPointRange,+ results: MutableList> = mutableListOf()+ ) = findOverlaps(interval.start, interval.endInclusive, results)++ /**+ * Finds all the intervals that overlap with the interval defined by [start] and [end].+ * [start] *must* be lesser than or equal to [end]. If [results] is specified, [results]+ * is returned, otherwise a new [MutableList] is returned.+ */+ fun findOverlaps(+ start: Float,+ end: Float = start,+ results: MutableList> = mutableListOf()+ ): MutableList> {+ if (root !== terminator) {+ findOverlaps(root, start, end, results)+ }+ return results+ }++ private fun findOverlaps(+ node: Node,+ start: Float,+ end: Float,+ results: MutableList>+ ) {+ if (node.interval.overlaps(start, end)) results.add(node.interval)+ if (node.left !== terminator && node.left.max >= start) {+ findOverlaps(node.left, start, end, results)+ }+ if (node.right !== terminator && node.right.min <= end) {+ findOverlaps(node.right, start, end, results)+ }+ }++ /**+ * Returns true if [value] is inside any of the intervals in this tree.+ */+ operator fun contains(value: Float) = findFirstOverlap(value, value) !== EmptyInterval++ /**+ * Returns true if the specified [interval] overlaps with any of the intervals+ * in this tree.+ */+ operator fun contains(interval: ClosedFloatingPointRange) =+ findFirstOverlap(interval.start, interval.endInclusive) !== EmptyInterval++ operator fun iterator(): Iterator> {+ return object : Iterator> {+ var next = root.lowestNode()++ override fun hasNext(): Boolean {+ return next !== terminator+ }++ override fun next(): Interval {+ val node = next+ next = next.next()+ return node.interval+ }+ }+ }++ /**+ * Adds the specified [Interval] to the interval tree.+ */+ operator fun plusAssign(interval: Interval) {+ val node = Node(interval)++ // Update the tree without doing any balancing+ var current = root+ var parent = terminator++ while (current !== terminator) {+ parent = current+ current = if (node.interval.start <= current.interval.start) {+ current.left+ } else {+ current.right+ }+ }++ node.parent = parent++ if (parent === terminator) {+ root = node+ } else {+ if (node.interval.start <= parent.interval.start) {+ parent.left = node+ } else {+ parent.right = node+ }+ }++ updateNodeData(node)++ rebalance(node)+ }++ private fun rebalance(target: Node) {+ var node = target++ while (node !== root && node.parent.color == TreeColor.Red) {+ val ancestor = node.parent.parent+ if (node.parent === ancestor.left) {+ val right = ancestor.right+ if (right.color == TreeColor.Red) {+ right.color = TreeColor.Black+ node.parent.color = TreeColor.Black+ ancestor.color = TreeColor.Red+ node = ancestor+ } else {+ if (node === node.parent.right) {+ node = node.parent+ rotateLeft(node)+ }+ node.parent.color = TreeColor.Black+ ancestor.color = TreeColor.Red+ rotateRight(ancestor)+ }+ } else {+ val left = ancestor.left+ if (left.color == TreeColor.Red) {+ left.color = TreeColor.Black+ node.parent.color = TreeColor.Black+ ancestor.color = TreeColor.Red+ node = ancestor+ } else {+ if (node === node.parent.left) {+ node = node.parent+ rotateRight(node)+ }+ node.parent.color = TreeColor.Black+ ancestor.color = TreeColor.Red+ rotateLeft(ancestor)+ }+ }+ }++ root.color = TreeColor.Black+ }++ private fun rotateLeft(node: Node) {+ val right = node.right+ node.right = right.left++ if (right.left !== terminator) {+ right.left.parent = node+ }++ right.parent = node.parent++ if (node.parent === terminator) {+ root = right+ } else {+ if (node.parent.left === node) {+ node.parent.left = right+ } else {+ node.parent.right = right+ }+ }++ right.left = node+ node.parent = right++ updateNodeData(node)+ }++ private fun rotateRight(node: Node) {+ val left = node.left+ node.left = left.right++ if (left.right !== terminator) {+ left.right.parent = node+ }++ left.parent = node.parent++ if (node.parent === terminator) {+ root = left+ } else {+ if (node.parent.right === node) {+ node.parent.right = left+ } else {+ node.parent.left = left+ }+ }++ left.right = node+ node.parent = left++ updateNodeData(node)+ }++ private fun updateNodeData(node: Node) {+ var current = node+ while (current !== terminator) {+ current.min = min(current.interval.start, min(current.left.min, current.right.min))+ current.max = max(current.interval.end, max(current.left.max, current.right.max))+ current = current.parent+ }+ }++ private enum class TreeColor {+ Red, Black+ }++ private inner class Node(val interval: Interval, var color: TreeColor = TreeColor.Red) {+ var min: Float = interval.start+ var max: Float = interval.end++ var left: Node = terminator+ var right: Node = terminator+ var parent: Node = terminator++ fun lowestNode(): Node {+ var node = this+ while (node.left !== terminator) {+ node = node.left+ }+ return node+ }++ fun next(): Node {+ if (right !== terminator) {+ return right.lowestNode()+ }++ var a = this+ var b = parent+ while (b !== terminator && a === b.right) {+ a = b+ b = b.parent+ }++ return b+ }+ }+}
@@ -18,8 +18,7 @@
import androidx.compose.runtime.Immutable import androidx.compose.ui.graphics.Path-import androidx.compose.ui.graphics.PathMeasure-import kotlin.math.absoluteValue+import androidx.compose.ui.graphics.PathSegment /** * An easing function for an arbitrary [Path].@@ -28,50 +27,30 @@
* [Path] is the input value and the output is the y coordinate of the line at that * point. This means that the Path must conform to a function `y = f(x)`. *- * The [Path] must not have gaps in the x direction and must not- * loop back on itself such that there can be two points sharing the same x coordinate.+ * The [Path] must be continuous along the x axis. The [Path] should also be+ * monotonically increasing along the x axis. If the [Path] is not monotonic and+ * there are multiple y values for a given x, the chosen y value is implementation+ * dependent and may vary.+ *+ * The [Path] must not contain any [Path.close] command as it would force the path+ * to restart from the beginning. * * This is equivalent to the Android `PathInterpolator`. *- * [CubicBezierEasing] should be used if a bezier curve is required as it performs less allocations.- * [PathEasing] should be used when creating an arbitrary path.+ * [CubicBezierEasing] should be used if a single bezier curve is required as it+ * performs fewer allocations. [PathEasing] should be used when creating an+ * arbitrary path.+ *+ * Note: a [PathEasing] instance can be used from any thread, but not concurrently. * * @sample androidx.compose.animation.core.samples.PathEasingSample *- * @param path The path to use to make the line representing the Easing Curve.+ * @param path The [Path] to use to make the curve representing the easing curve. * */ @Immutable-class PathEasing(path: Path) : Easing {-- private val offsetX: FloatArray- private val offsetY: FloatArray-- init {- val pathMeasure = PathMeasure()- pathMeasure.setPath(path, false)-- val pathLength: Float = pathMeasure.length- require(pathLength > 0) {- "Path cannot be zero in length. " +- "Ensure that supplied Path starts at [0,0] and ends at [1,1]"- }- val numPoints: Int =- (pathLength / Precision).toInt() + 1-- offsetX = FloatArray(numPoints) { 0f }- offsetY = FloatArray(numPoints) { 0f }-- for (i in 0 until numPoints) {- val distance = i * pathLength / (numPoints - 1)- val offset = pathMeasure.getPosition(distance)- offsetX[i] = offset.x- offsetY[i] = offset.y- if (i > 0 && offsetX[i] < offsetX[i - 1]) {- throw IllegalArgumentException("Path needs to be continuously increasing")- }- }- }+class PathEasing(private val path: Path) : Easing {+ private lateinit var intervals: IntervalTree override fun transform(fraction: Float): Float { if (fraction <= 0.0f) {@@ -80,32 +59,48 @@
return 1.0f }- // Do a binary search for the correct x to interpolate between.- val startIndex = offsetX.binarySearch(fraction)- // the index will be negative if an exact match is not found,- // so return the exact item if the index is positive.- if (startIndex > 0) {- return offsetY[startIndex]+ if (!::intervals.isInitialized) {+ val roots = FloatArray(5)++ // Using an interval tree is a bit heavy handed but since we are dealing with+ // easing curves, we don't expect many segments, and therefore few allocations.+ // The interval tree allows us to quickly query for the correct segment inside+ // the transform() function.+ val segmentIntervals = IntervalTree().apply {+ for (segment in path) {+ require(segment.type != PathSegment.Type.Close) {+ "The path cannot contain a close() command."+ }+ if (segment.type != PathSegment.Type.Move &&+ segment.type != PathSegment.Type.Done+ ) {+ val bounds = computeHorizontalBounds(segment, roots)+ this += Interval(bounds.first, bounds.second, segment)+ }+ }+ }++ require(0.0f in segmentIntervals) {+ "The easing path must start at 0.0f."+ }++ require(1.0f in segmentIntervals) {+ "The easing path must end at 1.0f."+ }++ intervals = segmentIntervals }- val insertionStartIndex = startIndex.absoluteValue- if (insertionStartIndex >= offsetX.size - 1) {- return offsetY.last()++ val result = intervals.findFirstOverlap(fraction)+ val segment = checkNotNull(result.data) {+ "The easing path is invalid. Make sure it is continuous on the x axis." }- val endIndex: Int = insertionStartIndex + 1- val xRange: Float = offsetX[endIndex] - offsetX[insertionStartIndex]+ val t = findFirstRoot(segment, fraction)+ check(!t.isNaN()) {+ "The easing path is invalid. Make sure it does not contain NaN/Infinity values."+ }- val tInRange: Float = fraction - offsetX[insertionStartIndex]- val newFraction = tInRange / xRange-- val startY: Float = offsetY[insertionStartIndex]- val endY: Float = offsetY[endIndex]-- return startY + newFraction * (endY - startY)+ return evaluateY(segment, t).coerceAtLeast(0.0f).coerceAtMost(1.0f) } }--/**- * Governs the accuracy of the approximation of [PathEasing].- */-private const val Precision = 0.002f
@@ -34,9 +34,15 @@
if (isTraceInProgress()) { traceEventStart(<>, %dirty, -1, <>) }- val a = remember({- A()- }, %composer, 0)+ val a = {+ %composer.startReplaceableGroup(<>)+ sourceInformation(%composer, "CC(remember):Test.kt#9igjgp")+ val tmp0_group = %composer.cache(false) {+ A()+ }+ %composer.endReplaceableGroup()+ tmp0_group+ } val = start until end.iterator() while (.hasNext()) { val i = .next()
@@ -34,9 +34,15 @@
if (isTraceInProgress()) { traceEventStart(<>, %dirty, -1, <>) }- val a = remember({- A()- }, %composer, 0)+ val a = {+ %composer.startReplaceableGroup(<>)+ sourceInformation(%composer, "CC(remember):Test.kt#9igjgp")+ val tmp0_group = %composer.cache(false) {+ A()+ }+ %composer.endReplaceableGroup()+ tmp0_group+ } val = start until end.iterator() while (.hasNext()) { val i = .next()
@@ -22,14 +22,18 @@
%composer = %composer.startRestartGroup(<>) sourceInformation(%composer, "C(Test),,:Test.kt") val %dirty = %changed- if (%changed and 0b1110 == 0) {- %dirty = %dirty or if (%default and 0b0001 == 0 && %composer.changed(a)) 0b0100 else 0b0010+ if (%default and 0b0001 != 0) {+ %dirty = %dirty or 0b0110+ } else if (%changed and 0b1110 == 0) {+ %dirty = %dirty or if (%composer.changed(a)) 0b0100 else 0b0010 } if (%changed and 0b01110000 == 0) { %dirty = %dirty or if (%default and 0b0010 == 0 && %composer.changed(b)) 0b00100000 else 0b00010000 }- if (%changed and 0b001110000000 == 0) {- %dirty = %dirty or if (%default and 0b0100 == 0 && %composer.changed(c)) 0b000100000000 else 0b10000000+ if (%default and 0b0100 != 0) {+ %dirty = %dirty or 0b000110000000+ } else if (%changed and 0b001110000000 == 0) {+ %dirty = %dirty or if (%composer.changed(c)) 0b000100000000 else 0b10000000 } if (%dirty and 0b001011011011 != 0b10010010 || !%composer.skipping) { %composer.startDefaults()@@ -44,7 +48,6 @@
%composer.endReplaceableGroup() tmp0_group }- %dirty = %dirty and 0b1110.inv() } if (%default and 0b0010 != 0) { b = SomeComposable(%composer, 0)@@ -60,19 +63,12 @@
%composer.endReplaceableGroup() tmp1_group }- %dirty = %dirty and 0b001110000000.inv() } } else { %composer.skipToGroupEnd()- if (%default and 0b0001 != 0) {- %dirty = %dirty and 0b1110.inv()- } if (%default and 0b0010 != 0) { %dirty = %dirty and 0b01110000.inv() }- if (%default and 0b0100 != 0) {- %dirty = %dirty and 0b001110000000.inv()- } } %composer.endDefaults() if (isTraceInProgress()) {
@@ -22,14 +22,18 @@
%composer = %composer.startRestartGroup(<>) sourceInformation(%composer, "C(Test),,:Test.kt") val %dirty = %changed- if (%changed and 0b1110 == 0) {- %dirty = %dirty or if (%default and 0b0001 == 0 && %composer.changed(a)) 0b0100 else 0b0010+ if (%default and 0b0001 != 0) {+ %dirty = %dirty or 0b0110+ } else if (%changed and 0b1110 == 0) {+ %dirty = %dirty or if (%composer.changed(a)) 0b0100 else 0b0010 } if (%changed and 0b01110000 == 0) { %dirty = %dirty or if (%default and 0b0010 == 0 && %composer.changed(b)) 0b00100000 else 0b00010000 }- if (%changed and 0b001110000000 == 0) {- %dirty = %dirty or if (%default and 0b0100 == 0 && %composer.changed(c)) 0b000100000000 else 0b10000000+ if (%default and 0b0100 != 0) {+ %dirty = %dirty or 0b000110000000+ } else if (%changed and 0b001110000000 == 0) {+ %dirty = %dirty or if (%composer.changed(c)) 0b000100000000 else 0b10000000 } if (%dirty and 0b001011011011 != 0b10010010 || !%composer.skipping) { %composer.startDefaults()@@ -44,7 +48,6 @@
%composer.endReplaceableGroup() tmp0_group }- %dirty = %dirty and 0b1110.inv() } if (%default and 0b0010 != 0) { b = SomeComposable(%composer, 0)@@ -60,19 +63,12 @@
%composer.endReplaceableGroup() tmp1_group }- %dirty = %dirty and 0b001110000000.inv() } } else { %composer.skipToGroupEnd()- if (%default and 0b0001 != 0) {- %dirty = %dirty and 0b1110.inv()- } if (%default and 0b0010 != 0) { %dirty = %dirty and 0b01110000.inv() }- if (%default and 0b0100 != 0) {- %dirty = %dirty and 0b001110000000.inv()- } } %composer.endDefaults() if (isTraceInProgress()) {
@@ -32,14 +32,14 @@
val bar = Bar(1) val lambda = { %composer.startReplaceableGroup(<>)- val tmpCache = %composer.cache(%composer.changedInstance(foo) or %composer.changed(bar)) {+ val tmp0_group = %composer.cache(%composer.changedInstance(foo) or %composer.changed(bar)) { { foo bar } } %composer.endReplaceableGroup()- tmpCache+ tmp0_group } if (isTraceInProgress()) { traceEventEnd()
@@ -32,14 +32,14 @@
val bar = Bar(1) val lambda = { %composer.startReplaceableGroup(<>)- val tmpCache = %composer.cache(%composer.changedInstance(foo) or %composer.changed(bar)) {+ val tmp0_group = %composer.cache(%composer.changedInstance(foo) or %composer.changed(bar)) { { foo bar } } %composer.endReplaceableGroup()- tmpCache+ tmp0_group } if (isTraceInProgress()) { traceEventEnd()
@@ -60,6 +60,7 @@
import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl import org.jetbrains.kotlin.ir.declarations.inlineClassRepresentation import org.jetbrains.kotlin.ir.declarations.name+import org.jetbrains.kotlin.ir.expressions.IrBlock import org.jetbrains.kotlin.ir.expressions.IrBranch import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrConst@@ -128,7 +129,6 @@
import org.jetbrains.kotlin.ir.util.getArgumentsWithIr import org.jetbrains.kotlin.ir.util.getPropertyGetter import org.jetbrains.kotlin.ir.util.hasAnnotation-import org.jetbrains.kotlin.ir.util.isFalseConst import org.jetbrains.kotlin.ir.util.isFunction import org.jetbrains.kotlin.ir.util.kotlinFqName import org.jetbrains.kotlin.ir.util.parentAsClass@@ -931,6 +931,11 @@
// K2 sometimes produces `IrGetField` for reads from constant properties symbol.owner.correspondingPropertySymbol?.owner?.isConst == true+ is IrBlock -> {+ // Check the slice in case the block was generated as expression+ // (e.g. inlined intrinsic remember call)+ context.irTrace[ComposeWritableSlices.IS_STATIC_EXPRESSION, this] ?: false+ } else -> false } }@@ -1036,12 +1041,6 @@
) { return true }- } else if (fqName == ComposeFqNames.cache) {- // If it is a call to cache then it is a transformed intrinsic call to- // remember and we need to- return valueArgumentsCount == 2 &&- getValueArgument(0)?.isFalseConst() == true &&- stabilityInferencer.stabilityOf(type).knownStable() } else if (fqName == ComposeFqNames.composableLambda) { // calls to this function are generated by the compiler, and this // function behaves similar to a remember call in that the result will
@@ -538,11 +538,11 @@
package androidx.compose.foundation.gestures.snapping { public final class LazyGridSnapLayoutInfoProviderKt {- method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.grid.LazyGridState lazyGridState, optional androidx.compose.foundation.gestures.snapping.SnapPositionInLayout positionInLayout);+ method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.grid.LazyGridState lazyGridState, optional androidx.compose.foundation.gestures.snapping.SnapPosition snapPosition); } public final class LazyListSnapLayoutInfoProviderKt {- method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.LazyListState lazyListState, optional androidx.compose.foundation.gestures.snapping.SnapPositionInLayout positionInLayout);+ method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.LazyListState lazyListState, optional androidx.compose.foundation.gestures.snapping.SnapPosition snapPosition); method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi @androidx.compose.runtime.Composable public static androidx.compose.foundation.gestures.FlingBehavior rememberSnapFlingBehavior(androidx.compose.foundation.lazy.LazyListState lazyListState); }@@ -562,14 +562,18 @@
method public float calculateSnappingOffset(float currentVelocity); }- @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public fun interface SnapPositionInLayout {+ @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public fun interface SnapPosition { method public int position(int layoutSize, int itemSize, int beforeContentPadding, int afterContentPadding, int itemIndex);- field public static final androidx.compose.foundation.gestures.snapping.SnapPositionInLayout.Companion Companion;+ field public static final androidx.compose.foundation.gestures.snapping.SnapPosition.Companion Companion; }- public static final class SnapPositionInLayout.Companion {- method public androidx.compose.foundation.gestures.snapping.SnapPositionInLayout getCenterToCenter();- property public final androidx.compose.foundation.gestures.snapping.SnapPositionInLayout CenterToCenter;+ public static final class SnapPosition.Companion {+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getCenter();+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getEnd();+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getStart();+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition Center;+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition End;+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition Start; } }
@@ -540,11 +540,11 @@
package androidx.compose.foundation.gestures.snapping { public final class LazyGridSnapLayoutInfoProviderKt {- method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.grid.LazyGridState lazyGridState, optional androidx.compose.foundation.gestures.snapping.SnapPositionInLayout positionInLayout);+ method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.grid.LazyGridState lazyGridState, optional androidx.compose.foundation.gestures.snapping.SnapPosition snapPosition); } public final class LazyListSnapLayoutInfoProviderKt {- method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.LazyListState lazyListState, optional androidx.compose.foundation.gestures.snapping.SnapPositionInLayout positionInLayout);+ method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public static androidx.compose.foundation.gestures.snapping.SnapLayoutInfoProvider SnapLayoutInfoProvider(androidx.compose.foundation.lazy.LazyListState lazyListState, optional androidx.compose.foundation.gestures.snapping.SnapPosition snapPosition); method @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi @androidx.compose.runtime.Composable public static androidx.compose.foundation.gestures.FlingBehavior rememberSnapFlingBehavior(androidx.compose.foundation.lazy.LazyListState lazyListState); }@@ -564,14 +564,18 @@
method public float calculateSnappingOffset(float currentVelocity); }- @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public fun interface SnapPositionInLayout {+ @SuppressCompatibility @androidx.compose.foundation.ExperimentalFoundationApi public fun interface SnapPosition { method public int position(int layoutSize, int itemSize, int beforeContentPadding, int afterContentPadding, int itemIndex);- field public static final androidx.compose.foundation.gestures.snapping.SnapPositionInLayout.Companion Companion;+ field public static final androidx.compose.foundation.gestures.snapping.SnapPosition.Companion Companion; }- public static final class SnapPositionInLayout.Companion {- method public androidx.compose.foundation.gestures.snapping.SnapPositionInLayout getCenterToCenter();- property public final androidx.compose.foundation.gestures.snapping.SnapPositionInLayout CenterToCenter;+ public static final class SnapPosition.Companion {+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getCenter();+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getEnd();+ method public androidx.compose.foundation.gestures.snapping.SnapPosition getStart();+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition Center;+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition End;+ property public final androidx.compose.foundation.gestures.snapping.SnapPosition Start; } }
@@ -35,7 +35,7 @@
* A [SnapLayoutInfoProvider] for LazyGrids. * * @param lazyGridState The [LazyGridState] with information about the current state of the grid- * @param positionInLayout The desired positioning of the snapped item within the main layout.+ * @param snapPosition The desired positioning of the snapped item within the main layout. * This position should be considered with regards to the start edge of the item and the placement * within the viewport. *@@ -44,7 +44,7 @@
@ExperimentalFoundationApi fun SnapLayoutInfoProvider( lazyGridState: LazyGridState,- positionInLayout: SnapPositionInLayout = SnapPositionInLayout.CenterToCenter+ snapPosition: SnapPosition = SnapPosition.Center ) = object : SnapLayoutInfoProvider { private val layoutInfo: LazyGridLayoutInfo get() = lazyGridState.layoutInfo@@ -93,7 +93,7 @@
itemSize = item.sizeOnMainAxis(orientation = layoutInfo.orientation), itemOffset = item.offsetOnMainAxis(orientation = layoutInfo.orientation), itemIndex = item.index,- snapPositionInLayout = positionInLayout+ snapPosition = snapPosition ) // Find item that is closest to the center
@@ -37,7 +37,7 @@
* A [SnapLayoutInfoProvider] for LazyLists. * * @param lazyListState The [LazyListState] with information about the current state of the list- * @param positionInLayout The desired positioning of the snapped item within the main layout.+ * @param snapPosition The desired positioning of the snapped item within the main layout. * This position should be considered with regard to the start edge of the item and the placement * within the viewport. *@@ -46,7 +46,7 @@
@ExperimentalFoundationApi fun SnapLayoutInfoProvider( lazyListState: LazyListState,- positionInLayout: SnapPositionInLayout = SnapPositionInLayout.CenterToCenter+ snapPosition: SnapPosition = SnapPosition.Center ): SnapLayoutInfoProvider = object : SnapLayoutInfoProvider { private val layoutInfo: LazyListLayoutInfo@@ -84,7 +84,7 @@
itemSize = item.size, itemOffset = item.offset, itemIndex = item.index,- snapPositionInLayout = positionInLayout+ snapPosition = snapPosition ) // Find item that is closest to the center
@@ -0,0 +1,104 @@
+/*+ * Copyright 2023 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 androidx.compose.foundation.gestures.snapping++import androidx.compose.foundation.ExperimentalFoundationApi++/**+ * Describes the general positioning of a given snap item in its containing layout.+ */+@ExperimentalFoundationApi+fun interface SnapPosition {+ /**+ * Calculates the anchor reference position where items will be snapped to in a snapping+ * container. For instance, if [SnapPosition.Center] is used, once the snapping finishes+ * one of the items in the snapping container will be aligned exactly to the position+ * returned by [position]. The value returned will be applied to the item's current offset+ * to generate its final positioning.+ *+ * The reference point is with respect to the start of the layout (including the content+ * padding).+ *+ * @param layoutSize The main axis layout size within which an item can be positioned.+ * @param itemSize The main axis size for the item being positioned within this snapping+ * layout.+ * @param beforeContentPadding The content padding in pixels applied before this Layout's+ * content.+ * @param afterContentPadding The content padding in pixels applied after this Layout's+ * content.+ * @param itemIndex The index of the item being positioned.+ */+ fun position(+ layoutSize: Int,+ itemSize: Int,+ beforeContentPadding: Int,+ afterContentPadding: Int,+ itemIndex: Int+ ): Int++ companion object {+ /**+ * Aligns the center of the item with the center of the containing layout.+ */+ val Center =+ SnapPosition { layoutSize, itemSize, beforeContentPadding, afterContentPadding, _ ->+ val availableLayoutSpace = layoutSize - beforeContentPadding - afterContentPadding+ // we use availableLayoutSpace / 2 as the main anchor point and we discount half+ // an item size so the item appear aligned with the center of the container.+ availableLayoutSpace / 2 - itemSize / 2+ }++ /**+ * Aligns the start of the item with the start of the containing layout.+ */+ val Start = SnapPosition { _, _, _, _, _ -> 0 }++ /**+ * Aligns the end of the item with the end of the containing layout.+ */+ val End =+ SnapPosition { layoutSize, itemSize, beforeContentPadding, afterContentPadding, _ ->+ val availableLayoutSpace = layoutSize - beforeContentPadding - afterContentPadding+ // the snap position for the item is the end of the layout, discounting the item+ // size+ availableLayoutSpace - itemSize+ }+ }+}++@OptIn(ExperimentalFoundationApi::class)+internal fun calculateDistanceToDesiredSnapPosition(+ mainAxisViewPortSize: Int,+ beforeContentPadding: Int,+ afterContentPadding: Int,+ itemSize: Int,+ itemOffset: Int,+ itemIndex: Int,+ snapPosition: SnapPosition+): Float {+ val desiredDistance = with(snapPosition) {+ position(+ mainAxisViewPortSize,+ itemSize,+ beforeContentPadding,+ afterContentPadding,+ itemIndex,+ )+ }.toFloat()++ return itemOffset - desiredDistance+}
@@ -1,83 +0,0 @@
-/*- * Copyright 2023 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 androidx.compose.foundation.gestures.snapping--import androidx.compose.foundation.ExperimentalFoundationApi--/**- * Describes the general positioning of a given snap item in its containing layout.- */-@ExperimentalFoundationApi-fun interface SnapPositionInLayout {- /**- * Calculates an offset positioning between a container and an element within this container.- * The offset calculation is the necessary diff that should be applied to the item offset to- * align the item with a position within the container. As a base line, if we wanted to align- * the start of the container and the start of the item, we would return 0 in this function.- *- * @param layoutSize The main axis layout size within which an item can be positioned.- * @param itemSize The main axis size for the item being positioned within this snapping- * layout.- * @param beforeContentPadding The content padding in pixels applied before this Layout's- * content.- * @param afterContentPadding The content padding in pixels applied after this Layout's- * content.- * @param itemIndex The index of the item being positioned.- */- fun position(- layoutSize: Int,- itemSize: Int,- beforeContentPadding: Int,- afterContentPadding: Int,- itemIndex: Int- ): Int-- companion object {- /**- * Aligns the center of the item with the center of the containing layout.- */- val CenterToCenter =- SnapPositionInLayout {- layoutSize, itemSize, beforeContentPadding, afterContentPadding, _ ->- val availableLayoutSpace = layoutSize - beforeContentPadding - afterContentPadding- availableLayoutSpace / 2 - itemSize / 2- }- }-}--@OptIn(ExperimentalFoundationApi::class)-internal fun calculateDistanceToDesiredSnapPosition(- mainAxisViewPortSize: Int,- beforeContentPadding: Int,- afterContentPadding: Int,- itemSize: Int,- itemOffset: Int,- itemIndex: Int,- snapPositionInLayout: SnapPositionInLayout-): Float {- val desiredDistance = with(snapPositionInLayout) {- position(- mainAxisViewPortSize,- itemSize,- beforeContentPadding,- afterContentPadding,- itemIndex,- )- }.toFloat()-- return itemOffset - desiredDistance-}
@@ -79,7 +79,7 @@
* If true is returned, only the placement phase is needed to apply new offsets. * If false is returned, it means we have to rerun the full measure phase to apply the [delta]. */- fun tryToApplyScrollWithoutRemeasure(delta: Int): Boolean {+ fun tryToApplyScrollWithoutRemeasure(delta: Int, updateAnimations: Boolean): Boolean { if (remeasureNeeded || visibleItemsInfo.isEmpty() || firstVisibleItem == null || // applying this delta will change firstVisibleItem (firstVisibleItemScrollOffset - delta) !in 0 until firstVisibleItem.sizeWithSpacings@@ -106,7 +106,7 @@
return if (canApply) { firstVisibleItemScrollOffset -= delta visibleItemsInfo.fastForEach {- it.applyScrollDelta(delta)+ it.applyScrollDelta(delta, updateAnimations) } consumedScroll = delta.toFloat() if (!canScrollForward && delta > 0) {
@@ -0,0 +1,53 @@
+/*+ * Copyright 2023 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 androidx.compose.material3.adaptive++import androidx.compose.foundation.layout.Box+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.height+import androidx.compose.runtime.Composable+import androidx.compose.runtime.CompositionLocalProvider+import androidx.compose.ui.Modifier+import androidx.compose.ui.platform.LocalDensity+import androidx.compose.ui.test.junit4.ComposeContentTestRule+import androidx.compose.ui.unit.Density+import androidx.compose.ui.unit.Dp+import androidx.compose.ui.unit.toSize++@OptIn(ExperimentalMaterial3AdaptiveApi::class)+internal fun ComposeContentTestRule.setContentWithSimulatedSize(+ simulatedWidth: Dp,+ simulatedHeight: Dp,+ content: @Composable () -> Unit+) {+ setContent {+ val currentDensity = LocalDensity.current+ val windowSize = with(currentDensity) {+ collectWindowSizeAsState().value.toSize().toDpSize();+ }+ val simulatedDensity = Density(+ currentDensity.density * (windowSize.width / simulatedWidth)+ )+ CompositionLocalProvider(LocalDensity provides simulatedDensity) {+ Box(+ Modifier.fillMaxWidth().height(simulatedHeight),+ ) {+ content()+ }+ }+ }+}
@@ -28,7 +28,10 @@
import androidx.compose.animation.slideOutHorizontally import androidx.compose.runtime.Composable import androidx.compose.runtime.Immutable+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clipToBounds import androidx.compose.ui.geometry.Offset@@ -149,11 +152,13 @@
}, )- val measurePolicy =- remember { ThreePaneContentMeasurePolicy(scaffoldDirective, scaffoldValue, ltrPaneOrder) }- measurePolicy.scaffoldDirective = scaffoldDirective- measurePolicy.scaffoldValue = scaffoldValue- measurePolicy.paneOrder = ltrPaneOrder+ val measurePolicy = remember {+ ThreePaneContentMeasurePolicy(scaffoldDirective, scaffoldValue, ltrPaneOrder)+ }.apply {+ this.scaffoldDirective = scaffoldDirective+ this.scaffoldValue = scaffoldValue+ this.paneOrder = ltrPaneOrder+ } LookaheadScope { Layout(@@ -328,10 +333,13 @@
@OptIn(ExperimentalMaterial3AdaptiveApi::class) private class ThreePaneContentMeasurePolicy(- var scaffoldDirective: PaneScaffoldDirective,- var scaffoldValue: ThreePaneScaffoldValue,- var paneOrder: ThreePaneScaffoldHorizontalOrder+ scaffoldDirective: PaneScaffoldDirective,+ scaffoldValue: ThreePaneScaffoldValue,+ paneOrder: ThreePaneScaffoldHorizontalOrder ) : MultiContentMeasurePolicy {+ var scaffoldDirective by mutableStateOf(scaffoldDirective)+ var scaffoldValue by mutableStateOf(scaffoldValue)+ var paneOrder by mutableStateOf(paneOrder) /** * Data class that is used to store the position and width of an expanded pane to be reused when@@ -642,6 +650,10 @@
// When panes are being hidden, apply each pane's width and position from the cache to // maintain the those before it's hidden by the AnimatedVisibility. measurables.fastForEach {+ if (!it.isAnimatedPane) {+ // When panes are not animated, we don't need to measure and place them.+ return+ } val cachedPanePlacement = placementsCache[it.role]!! it.measure( Constraints.fixed(@@ -684,6 +696,7 @@
AnimatedVisibility( visible = paneAdaptedValue == PaneAdaptedValue.Expanded, modifier = modifier+ .animatedPane() .clipToBounds(paneAdaptedValue) .then( if (paneAdaptedValue == PaneAdaptedValue.Expanded) {@@ -722,6 +735,8 @@
} else { data.preferredWidth!!.toInt() }++ val isAnimatedPane = data.isAnimatedPane } /**
@@ -1 +1,16 @@
// Signature format: 4.0+package androidx.compose.material3.common {++ @SuppressCompatibility @kotlin.RequiresOptIn(message="This material3-common API is experimental and is likely to change or to " + "be removed in the future.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface ExperimentalMaterial3CommonApi {+ }++ public final class InteractiveComponentSizeKt {+ method @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static androidx.compose.runtime.ProvidableCompositionLocal getLocalMinimumInteractiveComponentEnforcement();+ method @Deprecated @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static androidx.compose.runtime.ProvidableCompositionLocal getLocalMinimumTouchTargetEnforcement();+ method @androidx.compose.runtime.Stable public static androidx.compose.ui.Modifier minimumInteractiveComponentSize(androidx.compose.ui.Modifier);+ property @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static final androidx.compose.runtime.ProvidableCompositionLocal LocalMinimumInteractiveComponentEnforcement;+ property @Deprecated @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static final androidx.compose.runtime.ProvidableCompositionLocal LocalMinimumTouchTargetEnforcement;+ }++}+
@@ -1 +1,16 @@
// Signature format: 4.0+package androidx.compose.material3.common {++ @SuppressCompatibility @kotlin.RequiresOptIn(message="This material3-common API is experimental and is likely to change or to " + "be removed in the future.") @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) public @interface ExperimentalMaterial3CommonApi {+ }++ public final class InteractiveComponentSizeKt {+ method @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static androidx.compose.runtime.ProvidableCompositionLocal getLocalMinimumInteractiveComponentEnforcement();+ method @Deprecated @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static androidx.compose.runtime.ProvidableCompositionLocal getLocalMinimumTouchTargetEnforcement();+ method @androidx.compose.runtime.Stable public static androidx.compose.ui.Modifier minimumInteractiveComponentSize(androidx.compose.ui.Modifier);+ property @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static final androidx.compose.runtime.ProvidableCompositionLocal LocalMinimumInteractiveComponentEnforcement;+ property @Deprecated @SuppressCompatibility @androidx.compose.material3.common.ExperimentalMaterial3CommonApi public static final androidx.compose.runtime.ProvidableCompositionLocal LocalMinimumTouchTargetEnforcement;+ }++}+
@@ -0,0 +1,24 @@
+/*+ * Copyright 2023 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 androidx.compose.material3.common++@RequiresOptIn(+ "This material3-common API is experimental and is likely to change or to " ++ "be removed in the future."+)+@Retention(AnnotationRetention.BINARY)+annotation class ExperimentalMaterial3CommonApi
@@ -0,0 +1,171 @@
+/*+ * Copyright 2023 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 androidx.compose.material3.common++import androidx.compose.runtime.ProvidableCompositionLocal+import androidx.compose.runtime.Stable+import androidx.compose.runtime.staticCompositionLocalOf+import androidx.compose.ui.Modifier+import androidx.compose.ui.layout.LayoutModifier+import androidx.compose.ui.layout.Measurable+import androidx.compose.ui.layout.MeasureResult+import androidx.compose.ui.layout.MeasureScope+import androidx.compose.ui.node.CompositionLocalConsumerModifierNode+import androidx.compose.ui.node.LayoutModifierNode+import androidx.compose.ui.node.ModifierNodeElement+import androidx.compose.ui.node.currentValueOf+import androidx.compose.ui.platform.InspectorInfo+import androidx.compose.ui.unit.Constraints+import androidx.compose.ui.unit.DpSize+import androidx.compose.ui.unit.dp+import kotlin.math.roundToInt++/**+ * Reserves at least 48.dp in size to disambiguate touch interactions if the element would measure+ * smaller.+ *+ * https://m3.material.io/foundations/accessible-design/accessibility-basics+ *+ * This uses the Material recommended minimum size of 48.dp x 48.dp, which may not the same as the+ * system enforced minimum size. The minimum clickable / touch target size (48.dp by default) is+ * controlled by the system via ViewConfiguration and automatically expanded at the touch input+ * layer.+ *+ * This modifier is not needed for touch target expansion to happen. It only affects layout, to make+ * sure there is adequate space for touch target expansion.+ */+@Stable+fun Modifier.minimumInteractiveComponentSize(): Modifier = this then MinimumInteractiveModifier++internal object MinimumInteractiveModifier :+ ModifierNodeElement() {++ override fun create(): MinimumInteractiveModifierNode = MinimumInteractiveModifierNode()++ override fun update(node: MinimumInteractiveModifierNode) {}++ override fun InspectorInfo.inspectableProperties() {+ name = "minimumInteractiveComponentSize"+ // TODO: b/214589635 - surface this information through the layout inspector in a better way+ // - for now just add some information to help developers debug what this size represents.+ properties["README"] = "Reserves at least 48.dp in size to disambiguate touch " ++ "interactions if the element would measure smaller"+ }++ override fun hashCode(): Int = System.identityHashCode(this)+ override fun equals(other: Any?) = (other === this)+}++internal class MinimumInteractiveModifierNode :+ Modifier.Node(),+ CompositionLocalConsumerModifierNode,+ LayoutModifierNode {++ @OptIn(ExperimentalMaterial3CommonApi::class)+ override fun MeasureScope.measure(+ measurable: Measurable,+ constraints: Constraints+ ): MeasureResult {+ val size = minimumInteractiveComponentSize+ val placeable = measurable.measure(constraints)+ val enforcement = isAttached && currentValueOf(LocalMinimumInteractiveComponentEnforcement)++ // Be at least as big as the minimum dimension in both dimensions+ val width = if (enforcement) {+ maxOf(placeable.width, size.width.roundToPx())+ } else {+ placeable.width+ }+ val height = if (enforcement) {+ maxOf(placeable.height, size.height.roundToPx())+ } else {+ placeable.height+ }++ return layout(width, height) {+ val centerX = ((width - placeable.width) / 2f).roundToInt()+ val centerY = ((height - placeable.height) / 2f).roundToInt()+ placeable.place(centerX, centerY)+ }+ }+}++/**+ * CompositionLocal that configures whether Material components that have a visual size that is+ * lower than the minimum touch target size for accessibility (such as Button) will include+ * extra space outside the component to ensure that they are accessible. If set to false there+ * will be no extra space, and so it is possible that if the component is placed near the edge of+ * a layout / near to another component without any padding, there will not be enough space for+ * an accessible touch target.+ */+@Suppress("OPT_IN_MARKER_ON_WRONG_TARGET")+@get:ExperimentalMaterial3CommonApi+@ExperimentalMaterial3CommonApi+val LocalMinimumInteractiveComponentEnforcement: ProvidableCompositionLocal =+ staticCompositionLocalOf { true }++/**+ * CompositionLocal that configures whether Material components that have a visual size that is+ * lower than the minimum touch target size for accessibility (such as [Button]) will include+ * extra space outside the component to ensure that they are accessible. If set to false there+ * will be no extra space, and so it is possible that if the component is placed near the edge of+ * a layout / near to another component without any padding, there will not be enough space for+ * an accessible touch target.+ */+@Suppress("OPT_IN_MARKER_ON_WRONG_TARGET")+@get:ExperimentalMaterial3CommonApi+@ExperimentalMaterial3CommonApi+@Deprecated(+ message = "Use LocalMinimumInteractiveComponentEnforcement instead.",+ replaceWith = ReplaceWith(+ "LocalMinimumInteractiveComponentEnforcement"+ ),+ level = DeprecationLevel.WARNING+)+val LocalMinimumTouchTargetEnforcement: ProvidableCompositionLocal =+ LocalMinimumInteractiveComponentEnforcement++private class MinimumInteractiveComponentSizeModifier(val size: DpSize) : LayoutModifier {+ override fun MeasureScope.measure(+ measurable: Measurable,+ constraints: Constraints+ ): MeasureResult {++ val placeable = measurable.measure(constraints)++ // Be at least as big as the minimum dimension in both dimensions+ val width = maxOf(placeable.width, size.width.roundToPx())+ val height = maxOf(placeable.height, size.height.roundToPx())++ return layout(width, height) {+ val centerX = ((width - placeable.width) / 2f).roundToInt()+ val centerY = ((height - placeable.height) / 2f).roundToInt()+ placeable.place(centerX, centerY)+ }+ }++ override fun equals(other: Any?): Boolean {+ val otherModifier = other as? MinimumInteractiveComponentSizeModifier ?: return false+ return size == otherModifier.size+ }++ override fun hashCode(): Int {+ return size.hashCode()+ }+}++private val minimumInteractiveComponentSize: DpSize = DpSize(48.dp, 48.dp)
@@ -1,241 +0,0 @@
-/*- * Copyright 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 androidx.compose.runtime.collection--import androidx.compose.runtime.identityHashCode--internal class IdentityArrayIntMap {- var size = 0- private set- var keys: Array = arrayOfNulls(4)- private set- var values: IntArray = IntArray(4)- private set-- operator fun get(key: Any): Int {- val index = find(key)- return if (index >= 0) values[index] else error("Key not found")- }- /**- * Add [value] to the map and return `-1` if it was added or previous value if it already existed.- */- fun add(key: Any, value: Int): Int {- val values = values-- val index: Int- if (size > 0) {- index = find(key)- if (index >= 0) {- val previousValue = values[index]- values[index] = value- return previousValue- }- } else {- index = -1- }-- val insertIndex = -(index + 1)-- val keys = keys- val size = size- if (size == keys.size) {- val newKeys = arrayOfNulls(keys.size * 2)- val newValues = IntArray(keys.size * 2)- keys.copyInto(- destination = newKeys,- destinationOffset = insertIndex + 1,- startIndex = insertIndex,- endIndex = size- )- values.copyInto(- destination = newValues,- destinationOffset = insertIndex + 1,- startIndex = insertIndex,- endIndex = size- )- keys.copyInto(- destination = newKeys,- endIndex = insertIndex- )- values.copyInto(- destination = newValues,- endIndex = insertIndex- )- this.keys = newKeys- this.values = newValues- } else {- keys.copyInto(- destination = keys,- destinationOffset = insertIndex + 1,- startIndex = insertIndex,- endIndex = size- )- values.copyInto(- destination = values,- destinationOffset = insertIndex + 1,- startIndex = insertIndex,- endIndex = size- )- }- this.keys[insertIndex] = key- this.values[insertIndex] = value- this.size++-- return -1- }-- /**- * Remove [key] from the map.- */- fun remove(key: Any): Boolean {- val index = find(key)-- val keys = keys- val values = values- val size = size- if (index >= 0) {- if (index < size - 1) {- keys.copyInto(- destination = keys,- destinationOffset = index,- startIndex = index + 1,- endIndex = size- )- values.copyInto(- destination = values,- destinationOffset = index,- startIndex = index + 1,- endIndex = size- )- }- val newSize = size - 1- keys[newSize] = null- this.size = newSize- return true- }- return false- }-- /**- * Removes all values that match [predicate].- */- inline fun removeValueIf(predicate: (Any, Int) -> Boolean) {- val keys = keys- val values = values- val size = size-- var destinationIndex = 0- for (i in 0 until size) {- @Suppress("UNCHECKED_CAST")- val key = keys[i] as Any- val value = values[i]- if (!predicate(key, value)) {- if (destinationIndex != i) {- keys[destinationIndex] = key- values[destinationIndex] = value- }- destinationIndex++- }- }- for (i in destinationIndex until size) {- keys[i] = null- }- this.size = destinationIndex- }-- inline fun any(predicate: (Any, Int) -> Boolean): Boolean {- val keys = keys- val values = values- val size = size-- for (i in 0 until size) {- if (predicate(keys[i] as Any, values[i])) return true- }- return false- }-- inline fun forEach(block: (Any, Int) -> Unit) {- val keys = keys- val values = values- val size = size-- for (i in 0 until size) {- block(keys[i] as Any, values[i])- }- }-- /**- * Returns the index of [key] in the set or the negative index - 1 of the location where- * it would have been if it had been in the set.- */- private fun find(key: Any?): Int {- var low = 0- var high = size - 1- val valueIdentity = identityHashCode(key)-- val keys = keys- while (low <= high) {- val mid = (low + high).ushr(1)- val midVal = keys[mid]- val midIdentity = identityHashCode(midVal)- when {- midIdentity < valueIdentity -> low = mid + 1- midIdentity > valueIdentity -> high = mid - 1- midVal === key -> return mid- else -> return findExactIndex(mid, key, valueIdentity)- }- }- return -(low + 1)- }-- /**- * When multiple items share the same [identityHashCode], then we must find the specific- * index of the target item. This method assumes that [midIndex] has already been checked- * for an exact match for [value], but will look at nearby values to find the exact item index.- * If no match is found, the negative index - 1 of the position in which it would be will- * be returned, which is always after the last item with the same [identityHashCode].- */- private fun findExactIndex(midIndex: Int, value: Any?, valueHash: Int): Int {- val keys = keys- val size = size-- // hunt down first- for (i in midIndex - 1 downTo 0) {- val v = keys[i]- if (v === value) {- return i- }- if (identityHashCode(v) != valueHash) {- break // we've gone too far- }- }-- for (i in midIndex + 1 until size) {- val v = keys[i]- if (v === value) {- return i- }- if (identityHashCode(v) != valueHash) {- // We've gone too far. We should insert here.- return -(i + 1)- }- }-- // We should insert at the end- return -(size + 1)- }-}
@@ -1,127 +0,0 @@
-/*- * Copyright 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 androidx.compose.runtime.collection--import kotlin.test.Test-import kotlin.test.assertEquals-import kotlin.test.assertFalse-import kotlin.test.assertTrue--class IdentityArrayIntMapTests {-- @Test- fun emptyConstruction() {- val m = IdentityArrayIntMap()- assertEquals(0, m.size)- }-- @Test- fun canAddValues() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }- for (i in keys.indices) {- assertEquals(i, map[keys[i]])- }- map.removeValueIf { key, value ->- assertEquals(keys[value], key)- false- }- }-- @Test- fun addReturnsWhetherValueWasAdded() {- val map = IdentityArrayIntMap()- val key1 = Any()-- assertEquals(-1, map.add(key1, 0))- assertEquals(0, map.add(key1, 0))- assertEquals(0, map.add(key1, 1))- }-- @Test- fun canRemoveValues() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }- for (i in keys.indices step 2) {- map.remove(keys[i])- }- assertEquals(50, map.size)- map.removeValueIf { key, value ->- assertEquals(keys[value], key)- assertTrue(value % 2 == 1)- false- }- }-- @Test- fun canRemoveIfValues() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }- map.removeValueIf { _, value -> value % 2 == 0 }- assertEquals(50, map.size)- }-- @Test- fun canReplaceValues() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }-- for (i in keys.indices) {- map.add(keys[i], i + 100)- }-- assertEquals(100, map.size)- for (i in keys.indices) {- assertEquals(i + 100, map[keys[i]])- }- }-- @Test- fun anyFindsCorrectValue() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }- assertTrue(map.any { _, value -> value == 20 })- assertFalse(map.any { _, value -> value > 100 })- }-- @Test- fun canForEach() {- val map = IdentityArrayIntMap()- val keys = Array(100) { Any() }- for (i in keys.indices) {- map.add(keys[i], i)- }- map.forEach { key, value ->- assertEquals(keys.indexOf(key), value)- }- }-}
@@ -65,7 +65,9 @@
androidMain { dependsOn(jvmMain) dependencies {- implementation("androidx.graphics:graphics-path:1.0.0-alpha02")+ //TODO: Switch to pinned version when beta1 is released as it fixes bugs+ //implementation("androidx.graphics:graphics-path:1.0.0-beta01")+ implementation(project(":graphics:graphics-path")) api(libs.androidx.annotation) } }
@@ -44,17 +44,23 @@
focusPropertiesNodes.scheduleInvalidation(node) }+ fun hasPendingInvalidation(): Boolean {+ return focusTargetNodes.isNotEmpty() ||+ focusPropertiesNodes.isNotEmpty() ||+ focusEventNodes.isNotEmpty()+ }+ private fun MutableSet.scheduleInvalidation(node: T) { if (add(node)) { // If this is the first node scheduled for invalidation, // we set up a listener that runs after onApplyChanges. if (focusTargetNodes.size + focusEventNodes.size + focusPropertiesNodes.size == 1) {- onRequestApplyChangesListener.invoke(invalidateNodes)+ onRequestApplyChangesListener.invoke(::invalidateNodes) } } }- private val invalidateNodes: () -> Unit = {+ private fun invalidateNodes() { // Process all the invalidated FocusProperties nodes. focusPropertiesNodes.forEach { // We don't need to invalidate a focus properties node if it was scheduled for
@@ -200,6 +200,10 @@
* Dispatches a key event through the compose hierarchy. */ override fun dispatchKeyEvent(keyEvent: KeyEvent): Boolean {+ check(!focusInvalidationManager.hasPendingInvalidation()) {+ "Dispatching key event while focus system is invalidated."+ }+ if (!validateKeyEvent(keyEvent)) return false val activeFocusTarget = rootFocusNode.findActiveFocusNode()@@ -219,6 +223,10 @@
@OptIn(ExperimentalComposeUiApi::class) override fun dispatchInterceptedSoftKeyboardEvent(keyEvent: KeyEvent): Boolean {+ check(!focusInvalidationManager.hasPendingInvalidation()) {+ "Dispatching intercepted soft keyboard event while focus system is invalidated."+ }+ val focusedSoftKeyboardInterceptionNode = rootFocusNode.findActiveFocusNode() ?.nearestAncestor(Nodes.SoftKeyboardKeyInput)@@ -234,6 +242,10 @@
* Dispatches a rotary scroll event through the compose hierarchy. */ override fun dispatchRotaryEvent(event: RotaryScrollEvent): Boolean {+ check(!focusInvalidationManager.hasPendingInvalidation()) {+ "Dispatching rotary event while focus system is invalidated."+ }+ val focusedRotaryInputNode = rootFocusNode.findActiveFocusNode() ?.nearestAncestor(Nodes.RotaryInput)
@@ -78,12 +78,19 @@
* Clears focus if this focus target has it. */ override fun onReset() {+ // Note: onReset() is called after onEndApplyChanges, so we can't schedule any nodes for+ // invalidation here. If we do, they will be run on the next onEndApplyChanges. when (focusState) { // Clear focus from the current FocusTarget. // This currently clears focus from the entire hierarchy, but we can change the // implementation so that focus is sent to the immediate focus parent. Active, Captured -> requireOwner().focusOwner.clearFocus(force = true)- ActiveParent, Inactive -> scheduleInvalidationForFocusEvents()++ // If an ActiveParent is deactivated, the entire subtree containing focus is+ // deactivated, which means the Active node will also receive an onReset() call.+ // This triggers a clearFocus call, which will notify all the focus event nodes+ // associated with this FocusTargetNode.+ ActiveParent, Inactive -> {} } // This node might be reused, so we reset its state. committedFocusState = null@@ -185,16 +192,14 @@
} internal fun scheduleInvalidationForFocusEvents() {- // include possibility for ourselves to also be a focus event modifier node in case- // we are being delegated to- node.dispatchForKind(Nodes.FocusEvent) { eventNode ->- eventNode.invalidateFocusEvent()- } // Since this is potentially called while _this_ node is getting detached, it is possible // that the nodes above us are already detached, thus, we check for isAttached here. // We should investigate changing the order that children.detach() is called relative to // actually nulling out / detaching ones self.- visitAncestors(Nodes.FocusEvent or Nodes.FocusTarget) {+ visitAncestors(+ mask = Nodes.FocusEvent or Nodes.FocusTarget,+ includeSelf = true+ ) { if (it.isKind(Nodes.FocusTarget)) return@visitAncestors if (it.isAttached) {
@@ -30,13 +30,12 @@
import androidx.compose.ui.geometry.Rect import androidx.compose.ui.node.DelegatableNode import androidx.compose.ui.node.Nodes+import androidx.compose.ui.node.requireLayoutNode import androidx.compose.ui.node.visitChildren import kotlin.math.absoluteValue import kotlin.math.max-@Suppress("ConstPropertyName") private const val InvalidFocusDirection = "This function should only be used for 2-D focus search"-@Suppress("ConstPropertyName") private const val NoActiveChild = "ActiveParent must have a focusedChild" /**@@ -189,7 +188,7 @@
) { visitChildren(Nodes.FocusTarget) { // TODO(b/278765590): Find the root issue why visitChildren returns unattached nodes.- if (!it.isAttached) return@visitChildren+ if (!it.isAttached || it.requireLayoutNode().isDeactivated) return@visitChildren if (it.fetchFocusProperties().canFocus) { accessibleChildren.add(it)
@@ -23,6 +23,7 @@
import android.os.Bundle import androidx.glance.action.ActionParameters import androidx.glance.action.actionParametersOf+import androidx.glance.appwidget.action.ActionCallback import androidx.glance.testing.GlanceNodeAssertion import androidx.glance.testing.unit.GlanceMappedNode import androidx.glance.testing.unit.MappedNode@@ -48,6 +49,42 @@
fun UnitTestAssertion.assertIsNotChecked(): UnitTestAssertion = assert(isNotChecked()) /**+ * Asserts that a given node has a clickable set with action that runs a callback.+ *+ * @param callbackClass an implementation of [ActionCallback] that is expected to have been passed+ * in the `actionRunCallback` method call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionRunCallback` method call+ * @throws AssertionError if the matcher does not match or the node can no longer be found.+ */+fun UnitTestAssertion.assertHasRunCallbackClickAction(+ callbackClass: Class,+ parameters: ActionParameters = actionParametersOf()+): UnitTestAssertion = assert(+ hasRunCallbackClickAction(+ callbackClass = callbackClass,+ parameters = parameters+ )+)++/**+ * Asserts that a given node has a clickable set with action that runs a callback.+ *+ * @param T action callback that is expected to have been passed in the `actionRunCallback` method+ * call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionRunCallback` method call+ * @throws AssertionError if the matcher does not match or the node can no longer be found.+ */+inline fun UnitTestAssertion.assertHasRunCallbackClickAction(+ parameters: ActionParameters = actionParametersOf()+): UnitTestAssertion = assert(+ hasRunCallbackClickAction(+ parameters = parameters+ )+)++/** * Asserts that a given node has a clickable set with action that starts an activity. * * @param intent the intent for launching an activity that is expected to have been passed in the@@ -87,6 +124,19 @@
/** * Asserts that a given node has a clickable set with action that starts a service. *+ * @param T class of the service to launch that is expected to have been passed in the+ * `actionStartService` method call.+ * @param isForegroundService if the service to launch is expected to have been set as foreground+ * service in the `actionStartService` method call.+ * @throws AssertionError if the matcher does not match or the node can no longer be found.+ */+inline fun UnitTestAssertion.assertHasStartServiceClickAction(+ isForegroundService: Boolean = false+): UnitTestAssertion = assert(hasStartServiceAction(isForegroundService))++/**+ * Asserts that a given node has a clickable set with action that starts a service.+ * * @param componentName component of the service to launch that is expected to have been passed in * the `actionStartService` method call. * @param isForegroundService if the service to launch is expected to have been set as foreground@@ -126,6 +176,17 @@
/** * Asserts that a given node has a clickable set with action that sends a broadcast. *+ * @param T class of the broadcast receiver that is expected to have been passed in the+ * `actionSendBroadcast` method call.+ * @throws AssertionError if the matcher does not match or the node can no longer be found.+ */+inline fun + UnitTestAssertion.assertHasSendBroadcastClickAction(): UnitTestAssertion =+ assert(hasSendBroadcastAction())++/**+ * Asserts that a given node has a clickable set with action that sends a broadcast.+ * * @param intentAction the intent action of the broadcast receiver that is expected to have been * passed in the `actionSendBroadcast` method call. * @param componentName optional [ComponentName] of the target broadcast receiver that is expected
@@ -27,6 +27,8 @@
import androidx.glance.action.actionParametersOf import androidx.glance.appwidget.EmittableCircularProgressIndicator import androidx.glance.appwidget.EmittableLinearProgressIndicator+import androidx.glance.appwidget.action.ActionCallback+import androidx.glance.appwidget.action.RunCallbackAction import androidx.glance.appwidget.action.SendBroadcastActionAction import androidx.glance.appwidget.action.SendBroadcastClassAction import androidx.glance.appwidget.action.SendBroadcastComponentAction@@ -70,6 +72,55 @@
} /**+ * Returns a matcher that matches if a node has a clickable set with action that runs a callback.+ *+ * This can be passed in [GlanceNodeAssertionsProvider.onNode] and+ * [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out+ * matching node(s) or in assertions to validate that node(s) satisfy the condition.+ *+ * @param callbackClass an implementation of [ActionCallback] that is expected to have been passed+ * in the `actionRunCallback` method call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionRunCallback` method call+ */+fun hasRunCallbackClickAction(+ callbackClass: Class,+ parameters: ActionParameters = actionParametersOf()+): GlanceNodeMatcher = GlanceNodeMatcher(+ "has run callback click action with callback class: ${callbackClass.name} and " ++ "parameters: $parameters"+) { node ->+ node.value.emittable.modifier.any {+ if (it is ActionModifier) {+ val action = it.action+ if (action is RunCallbackAction) {+ return@any action.callbackClass == callbackClass && action.parameters == parameters+ }+ }+ false+ }+}++/**+ * Returns a matcher that matches if a node has a clickable set with action that runs a callback.+ *+ * This can be passed in [GlanceNodeAssertionsProvider.onNode] and+ * [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out+ * matching node(s) or in assertions to validate that node(s) satisfy the condition.+ *+ * @param T callback class that is expected to have been passed in the `actionRunCallback` method+ * call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionRunCallback` method call+ */+inline fun hasRunCallbackClickAction(+ parameters: ActionParameters = actionParametersOf()+): GlanceNodeMatcher = hasRunCallbackClickAction(+ callbackClass = T::class.java,+ parameters = parameters+)++/** * Returns a matcher that matches if a node has a clickable set with action that starts an activity. * * This can be passed in [GlanceNodeAssertionsProvider.onNode] and@@ -154,6 +205,25 @@
* [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out * matching node(s) or in assertions to validate that node(s) satisfy the condition. *+ * @param T class of the service to launch that is expected to have been passed in the+ * `actionStartService` method call.+ * @param isForegroundService if the service to launch is expected to have been set as foreground+ * service in the `actionStartService` method call.+ */+inline fun hasStartServiceAction(+ isForegroundService: Boolean = false+): GlanceNodeMatcher = hasStartServiceAction(+ serviceClass = T::class.java,+ isForegroundService = isForegroundService+)++/**+ * Returns a matcher that matches if a node has a clickable set with action that starts a service.+ *+ * This can be passed in [GlanceNodeAssertionsProvider.onNode] and+ * [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out+ * matching node(s) or in assertions to validate that node(s) satisfy the condition.+ * * @param componentName component of the service to launch that is expected to have been passed in * the `actionStartService` method call. * @param isForegroundService if the service to launch is expected to have been set as foreground@@ -248,6 +318,19 @@
* [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out * matching node(s) or in assertions to validate that node(s) satisfy the condition. *+ * @param T class of the broadcast receiver that is expected to have been passed in the+ * actionSendBroadcast` method call.+ */+inline fun hasSendBroadcastAction(): GlanceNodeMatcher =+ hasSendBroadcastAction(T::class.java)++/**+ * Returns a matcher that matches if a node has a clickable set with action that sends a broadcast.+ *+ * This can be passed in [GlanceNodeAssertionsProvider.onNode] and+ * [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out+ * matching node(s) or in assertions to validate that node(s) satisfy the condition.+ * * @param intentAction the intent action of the broadcast receiver that is expected to have been * passed in the `actionSendBroadcast` method call. * @param componentName optional [ComponentName] of the target broadcast receiver that is expected
@@ -0,0 +1,61 @@
+/*+ * Copyright 2023 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 androidx.glance.material3++import androidx.compose.runtime.Composable+import androidx.compose.ui.unit.dp+import androidx.glance.GlanceModifier+import androidx.glance.GlanceTheme+import androidx.glance.appwidget.appWidgetBackground+import androidx.glance.background+import androidx.glance.layout.Box+import androidx.glance.layout.Column+import androidx.glance.layout.ColumnScope+import androidx.glance.layout.fillMaxSize+import androidx.glance.layout.padding+import androidx.glance.unit.ColorProvider++/**+ * A simple slot api component for displaying widget UI with a [TitleBar]. Sets the background color+ * to `GlanceTheme.colors.surface` and applies padding. This is intended to be used as a top level+ * component.+ *+ * @param titleBar A composable that creates the [TitleBar]+ * @param content The main content of the widget.+ * @param modifier a modifier+ * @param backgroundColor the background color for the layout.+ */+@Composable+fun Scaffold(+ titleBar: @Composable () -> Unit,+ content: @Composable ColumnScope.() -> Unit,+ modifier: GlanceModifier = GlanceModifier,+ backgroundColor: ColorProvider = GlanceTheme.colors.surface+) {+ Box(modifier+ .fillMaxSize()+ .background(backgroundColor)+ .appWidgetBackground()+ ) {+ Column(GlanceModifier.fillMaxSize()) {+ titleBar()+ Box(GlanceModifier.padding(horizontal = 16.dp)) {+ content()+ }+ }+ }+}
@@ -146,6 +146,25 @@
/** * Asserts that a given node has a clickable set with action that starts an activity. *+ * @param T class of the activity that is expected to have been passed in the+ * `actionStartActivity` method call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionStartActivity` method call+ * @param activityOptions Additional options built from an [android.app.ActivityOptions] that are+ * expected to have been passed in the `actionStartActivity` method call+ * @throws AssertionError if the matcher does not match or the node can no longer be found.+ */+@JvmOverloads+inline fun UnitTestAssertion.assertHasStartActivityClickAction(+ parameters: ActionParameters = actionParametersOf(),+ activityOptions: Bundle? = null+): UnitTestAssertion {+ return assert(hasStartActivityClickAction(parameters, activityOptions))+}++/**+ * Asserts that a given node has a clickable set with action that starts an activity.+ * * @param componentName component of the activity that is expected to have been passed in the * `actionStartActivity` method call * @param parameters the parameters associated with the action that are expected to have been passed
@@ -265,6 +265,31 @@
} /**+ * Returns a matcher that matches if a given node has a clickable set with action that starts an+ * activity.+ *+ * This can be passed in [GlanceNodeAssertionsProvider.onNode] and+ * [GlanceNodeAssertionsProvider.onAllNodes] functions on assertion providers to filter out+ * matching node(s) or in assertions to validate that node(s) satisfy the condition.+ *+ * @param T class of the activity that is expected to have been passed in the+ * `actionStartActivity` method call+ * @param parameters the parameters associated with the action that are expected to have been passed+ * in the `actionStartActivity` method call+ * @param activityOptions Additional options built from an [android.app.ActivityOptions] that are+ * expected to have been passed in the `actionStartActivity` method call+ */+inline fun hasStartActivityClickAction(+ parameters: ActionParameters = actionParametersOf(),+ activityOptions: Bundle? = null+): GlanceNodeMatcher =+ hasStartActivityClickAction(+ activityClass = T::class.java,+ parameters = parameters,+ activityOptions = activityOptions+ )++/** * Returns a matcher that matches if a given node has a descendant node somewhere in its * sub-hierarchy that the matches the provided matcher. *
@@ -31,9 +31,6 @@
android.nonFinalResIds=false android.experimental.lint.missingBaselineIsEmptyBaseline=true android.experimental.lint.reservedMemoryPerTask=1g-# Required for Privacy Sandbox projects.-android.experimental.privacysandboxsdk.enable=true-android.experimental.privacysandboxsdk.requireServices=false # Do generate versioned API files androidx.writeVersionedApiFiles=true@@ -60,7 +57,7 @@
# Disallow resolving dependencies at configuration time, which is a slight performance problem android.dependencyResolutionAtConfigurationTime.disallow=true-android.suppressUnsupportedOptionWarnings=android.suppressUnsupportedOptionWarnings,android.dependencyResolutionAtConfigurationTime.disallow,android.experimental.lint.missingBaselineIsEmptyBaseline,android.lint.printStackTrace,android.lint.baselineOmitLineNumbers,android.experimental.disableCompileSdkChecks,android.overrideVersionCheck,android.r8.maxWorkers,android.experimental.privacysandboxsdk.enable,android.experimental.lint.reservedMemoryPerTask,android.experimental.privacysandboxsdk.requireServices+android.suppressUnsupportedOptionWarnings=android.suppressUnsupportedOptionWarnings,android.dependencyResolutionAtConfigurationTime.disallow,android.experimental.lint.missingBaselineIsEmptyBaseline,android.lint.printStackTrace,android.lint.baselineOmitLineNumbers,android.experimental.disableCompileSdkChecks,android.overrideVersionCheck,android.r8.maxWorkers,android.experimental.privacysandboxsdk.enable,android.experimental.lint.reservedMemoryPerTask # Workaround for b/162074215 android.includeDependencyInfoInApks=false # Allow multiple r8 tasks at once because otherwise they can make the critical path longer: b/256187923
@@ -1,4 +1,55 @@
// Signature format: 4.0+package androidx.graphics {++ @RequiresApi(android.os.Build.VERSION_CODES.Q) public final class CanvasBufferedRenderer implements java.lang.AutoCloseable {+ method public void close();+ method public int getBufferFormat();+ method public int getMaxBuffers();+ method public long getUsageFlags();+ method public boolean isClosed();+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest obtainRenderRequest();+ method public void releaseBuffer(android.hardware.HardwareBuffer hardwareBuffer, androidx.hardware.SyncFenceCompat? fence);+ method public void setContentRoot(android.graphics.RenderNode renderNode);+ method public void setLightSourceAlpha(float ambientShadowAlpha, float spotShadowAlpha);+ method public void setLightSourceGeometry(float lightX, float lightY, float lightZ, float lightRadius);+ property public final int bufferFormat;+ property public final int maxBuffers;+ property public final long usageFlags;+ }++ public static final class CanvasBufferedRenderer.Builder {+ ctor public CanvasBufferedRenderer.Builder(int width, int height);+ method public androidx.graphics.CanvasBufferedRenderer build();+ method public androidx.graphics.CanvasBufferedRenderer.Builder setBufferFormat(int format);+ method public androidx.graphics.CanvasBufferedRenderer.Builder setMaxBuffers(@IntRange(from=1L, to=64L) int numBuffers);+ method public androidx.graphics.CanvasBufferedRenderer.Builder setUsageFlags(long usageFlags);+ }++ public final class CanvasBufferedRenderer.RenderRequest {+ method public void draw(java.util.concurrent.Executor executor, androidx.core.util.Consumer callback);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest preserveContents(boolean preserve);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest setBufferTransform(int bufferTransform);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest setColorSpace(android.graphics.ColorSpace? colorSpace);+ }++ public static final class CanvasBufferedRenderer.RenderResult {+ ctor public CanvasBufferedRenderer.RenderResult(android.hardware.HardwareBuffer buffer, androidx.hardware.SyncFenceCompat? mFence, int mStatus);+ method public androidx.hardware.SyncFenceCompat? getFence();+ method public android.hardware.HardwareBuffer getHardwareBuffer();+ method public int getStatus();+ property public final androidx.hardware.SyncFenceCompat? fence;+ property public final android.hardware.HardwareBuffer hardwareBuffer;+ property public final int status;+ field public static final androidx.graphics.CanvasBufferedRenderer.RenderResult.Companion Companion;+ field public static final int ERROR_UNKNOWN = 1; // 0x1+ field public static final int SUCCESS = 0; // 0x0+ }++ public static final class CanvasBufferedRenderer.RenderResult.Companion {+ }++}+ package androidx.graphics.lowlatency { public final class BufferInfo {@@ -12,9 +63,11 @@
@RequiresApi(android.os.Build.VERSION_CODES.Q) public final class CanvasFrontBufferedRenderer { ctor public CanvasFrontBufferedRenderer(android.view.SurfaceView surfaceView, androidx.graphics.lowlatency.CanvasFrontBufferedRenderer.Callback callback);+ ctor public CanvasFrontBufferedRenderer(android.view.SurfaceView surfaceView, androidx.graphics.lowlatency.CanvasFrontBufferedRenderer.Callback callback, optional int bufferFormat); method public void cancel(); method public void clear(); method public void commit();+ method public int getBufferFormat(); method public android.graphics.ColorSpace getColorSpace(); method public boolean isValid(); method public void release(boolean cancelPending);@@ -22,6 +75,7 @@
method public void renderFrontBufferedLayer(T param); method public void renderMultiBufferedLayer(java.util.Collection params); method public void setColorSpace(android.graphics.ColorSpace);+ property public final int bufferFormat; property public final android.graphics.ColorSpace colorSpace; }
@@ -1,4 +1,55 @@
// Signature format: 4.0+package androidx.graphics {++ @RequiresApi(android.os.Build.VERSION_CODES.Q) public final class CanvasBufferedRenderer implements java.lang.AutoCloseable {+ method public void close();+ method public int getBufferFormat();+ method public int getMaxBuffers();+ method public long getUsageFlags();+ method public boolean isClosed();+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest obtainRenderRequest();+ method public void releaseBuffer(android.hardware.HardwareBuffer hardwareBuffer, androidx.hardware.SyncFenceCompat? fence);+ method public void setContentRoot(android.graphics.RenderNode renderNode);+ method public void setLightSourceAlpha(float ambientShadowAlpha, float spotShadowAlpha);+ method public void setLightSourceGeometry(float lightX, float lightY, float lightZ, float lightRadius);+ property public final int bufferFormat;+ property public final int maxBuffers;+ property public final long usageFlags;+ }++ public static final class CanvasBufferedRenderer.Builder {+ ctor public CanvasBufferedRenderer.Builder(int width, int height);+ method public androidx.graphics.CanvasBufferedRenderer build();+ method public androidx.graphics.CanvasBufferedRenderer.Builder setBufferFormat(int format);+ method public androidx.graphics.CanvasBufferedRenderer.Builder setMaxBuffers(@IntRange(from=1L, to=64L) int numBuffers);+ method public androidx.graphics.CanvasBufferedRenderer.Builder setUsageFlags(long usageFlags);+ }++ public final class CanvasBufferedRenderer.RenderRequest {+ method public void draw(java.util.concurrent.Executor executor, androidx.core.util.Consumer callback);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest preserveContents(boolean preserve);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest setBufferTransform(int bufferTransform);+ method public androidx.graphics.CanvasBufferedRenderer.RenderRequest setColorSpace(android.graphics.ColorSpace? colorSpace);+ }++ public static final class CanvasBufferedRenderer.RenderResult {+ ctor public CanvasBufferedRenderer.RenderResult(android.hardware.HardwareBuffer buffer, androidx.hardware.SyncFenceCompat? mFence, int mStatus);+ method public androidx.hardware.SyncFenceCompat? getFence();+ method public android.hardware.HardwareBuffer getHardwareBuffer();+ method public int getStatus();+ property public final androidx.hardware.SyncFenceCompat? fence;+ property public final android.hardware.HardwareBuffer hardwareBuffer;+ property public final int status;+ field public static final androidx.graphics.CanvasBufferedRenderer.RenderResult.Companion Companion;+ field public static final int ERROR_UNKNOWN = 1; // 0x1+ field public static final int SUCCESS = 0; // 0x0+ }++ public static final class CanvasBufferedRenderer.RenderResult.Companion {+ }++}+ package androidx.graphics.lowlatency { public final class BufferInfo {@@ -12,9 +63,11 @@
@RequiresApi(android.os.Build.VERSION_CODES.Q) public final class CanvasFrontBufferedRenderer { ctor public CanvasFrontBufferedRenderer(android.view.SurfaceView surfaceView, androidx.graphics.lowlatency.CanvasFrontBufferedRenderer.Callback callback);+ ctor public CanvasFrontBufferedRenderer(android.view.SurfaceView surfaceView, androidx.graphics.lowlatency.CanvasFrontBufferedRenderer.Callback callback, optional int bufferFormat); method public void cancel(); method public void clear(); method public void commit();+ method public int getBufferFormat(); method public android.graphics.ColorSpace getColorSpace(); method public boolean isValid(); method public void release(boolean cancelPending);@@ -22,6 +75,7 @@
method public void renderFrontBufferedLayer(T param); method public void renderMultiBufferedLayer(java.util.Collection params); method public void setColorSpace(android.graphics.ColorSpace);+ property public final int bufferFormat; property public final android.graphics.ColorSpace colorSpace; }
@@ -0,0 +1,495 @@
+/*+ * Copyright 2023 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 androidx.graphics++import android.graphics.ColorSpace+import android.graphics.RenderNode+import android.hardware.HardwareBuffer+import android.os.Build+import android.view.SurfaceControl+import androidx.annotation.IntRange+import androidx.annotation.RequiresApi+import androidx.core.util.Consumer+import androidx.graphics.surface.SurfaceControlCompat+import androidx.graphics.surface.SurfaceControlCompat.Companion.BufferTransform+import androidx.hardware.DefaultFlags+import androidx.hardware.DefaultNumBuffers+import androidx.hardware.HardwareBufferFormat+import androidx.hardware.HardwareBufferUsage+import androidx.hardware.SyncFenceCompat+import java.lang.IllegalStateException+import java.util.concurrent.Executor++/**+ * Creates an instance of a hardware-accelerated renderer. This is used to render a scene built+ * from [RenderNode]s to an output [HardwareBuffer]. There can be as many+ * HardwareBufferRenderer instances as desired.+ *+ * Resources & lifecycle+ *+ * All [CanvasBufferedRenderer] instances share a common render+ * thread. Therefore [CanvasBufferedRenderer] will share common resources and GPU utilization+ * with hardware accelerated rendering initiated by the UI thread of an application.+ * The render thread contains the GPU context & resources necessary to do GPU-accelerated+ * rendering. As such, the first [CanvasBufferedRenderer] created comes with the cost of also+ * creating the associated GPU contexts, however each incremental [CanvasBufferedRenderer]+ * thereafter is fairly cheap.+ *+ * This is useful in situations where a scene built with [RenderNode]+ * [SurfaceControlCompat.Transaction.setBuffer].+ *+ * [CanvasBufferedRenderer] can optionally persist contents before each draw invocation so+ * previous contents in the [HardwareBuffer] target will be preserved across renders. This is+ * determined by the argument provided to+ * [CanvasBufferedRenderer.RenderRequest.preserveContents] which is set to `false` by default.+*/+@RequiresApi(Build.VERSION_CODES.Q)+class CanvasBufferedRenderer internal constructor(+ width: Int,+ height: Int,+ private val mFormat: Int,+ private val mUsage: Long,+ private val mMaxBuffers: Int,+ useImpl: Int = DEFAULT_IMPL,+) : AutoCloseable {++ private val mImpl: Impl = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE &&+ useImpl == DEFAULT_IMPL+ ) {+ CanvasBufferedRendererV34(+ width,+ height,+ mFormat,+ mUsage,+ mMaxBuffers+ )+ } else {+ CanvasBufferedRendererV29(+ width,+ height,+ mFormat,+ mUsage,+ mMaxBuffers,+ useImpl+ )+ }++ private val mRenderRequest = RenderRequest()++ /**+ * Returns the number of buffers within the swap chain used for rendering with this+ * [CanvasBufferedRenderer]+ */+ val maxBuffers: Int+ get() = mMaxBuffers++ /**+ * Returns the [HardwareBufferFormat] of the buffers that are being rendered into by this+ * [CanvasBufferedRenderer]+ */+ @HardwareBufferFormat+ val bufferFormat: Int+ get() = mFormat++ /**+ * Returns the current usage flag hints of the buffers that are being rendered into by this+ * [CanvasBufferedRenderer]+ */+ @HardwareBufferUsage+ val usageFlags: Long+ get() = mUsage++ /**+ * Releases the resources associated with this [CanvasBufferedRenderer] instance.+ * **Note** this does not call [HardwareBuffer.close] on the provided [HardwareBuffer] instance.+ */+ override fun close() {+ mImpl.close()+ }++ /**+ * Returns if the [CanvasBufferedRenderer] has already been closed. That is+ * [CanvasBufferedRenderer.close] has been invoked.+ */+ fun isClosed(): Boolean = mImpl.isClosed()++ /**+ * Returns a [RenderRequest] that can be used to render into the provided HardwareBuffer.+ * This is used to synchronize the RenderNode content provided by [setContentRoot].+ */+ fun obtainRenderRequest(): RenderRequest {+ mRenderRequest.reset()+ return mRenderRequest+ }++ /**+ * Sets the content root to render. It is not necessary to call this whenever the content+ * recording changes. Any mutations to the [RenderNode] content, or any of the [RenderNode]s+ * contained within the content node, will be applied whenever a new [RenderRequest] is issued+ * via [obtainRenderRequest] and [RenderRequest.draw].+ */+ fun setContentRoot(renderNode: RenderNode) {+ mImpl.setContentRoot(renderNode)+ }++ /**+ * Configures the ambient & spot shadow alphas. This is the alpha used when the shadow has+ * max alpha, and ramps down from the values provided to zero.+ *+ * These values are typically provided by the current theme, see R.attr.spotShadowAlpha and+ * R.attr.ambientShadowAlpha.+ *+ * This must be set at least once along with [setLightSourceGeometry] before shadows will work.+ */+ fun setLightSourceAlpha(+ ambientShadowAlpha: Float,+ spotShadowAlpha: Float,+ ) {+ mImpl.setLightSourceAlpha(ambientShadowAlpha, spotShadowAlpha)+ }++ /**+ * Sets the center of the light source. The light source point controls the directionality and+ * shape of shadows rendered by [RenderNode] Z & elevation.+ *+ * The light source should be setup both as part of initial configuration, and whenever the+ * window moves to ensure the light source stays anchored in display space instead of in+ * window space.+ *+ * This must be set at least once along with [setLightSourceAlpha] before shadows will work.+ */+ fun setLightSourceGeometry(+ lightX: Float,+ lightY: Float,+ lightZ: Float,+ lightRadius: Float+ ) {+ mImpl.setLightSourceGeometry(lightX, lightY, lightZ, lightRadius)+ }++ /**+ * Builder used to construct a [CanvasBufferedRenderer] instance.+ * @param width Width of the buffers created by the [CanvasBufferedRenderer] instance+ * @param height Height of the buffers created by the [CanvasBufferedRenderer] instance+ */+ class Builder(private val width: Int, private val height: Int) {++ private var mBufferFormat = HardwareBuffer.RGBA_8888+ private var mMaxBuffers = DefaultNumBuffers+ private var mUsageFlags = DefaultFlags+ private var mImpl = DEFAULT_IMPL++ /**+ * Specify the buffer format of the underlying buffers being rendered into by the created+ * [CanvasBufferedRenderer]. The set of valid formats is implementation-specific.+ * The particular valid combinations for a given Android version and implementation should+ * be documented by that version.+ *+ * [HardwareBuffer.RGBA_8888] and [HardwareBuffer.RGBX_8888] are guaranteed to be supported.+ * However, consumers are recommended to query the desired [HardwareBuffer] configuration+ * using [HardwareBuffer.isSupported].+ *+ * @param format Pixel format of the buffers to be rendered into. The default is RGBA_8888.+ *+ * @return The builder instance+ */+ fun setBufferFormat(@HardwareBufferFormat format: Int): Builder {+ mBufferFormat = format+ return this+ }++ /**+ * Specify the maximum number of buffers used within the swap chain of the+ * [CanvasBufferedRenderer].+ * If 1 is specified, then the created [CanvasBufferedRenderer] is running in+ * "single buffer mode". In this case consumption of the buffer content would need to be+ * coordinated with the [SyncFenceCompat] returned by the callback of [RenderRequest.draw].+ * @see CanvasBufferedRenderer.RenderRequest.draw+ *+ * @param numBuffers The number of buffers within the swap chain to be consumed by the+ * created [CanvasBufferedRenderer]. This must be greater than zero. The default+ * number of buffers used is 3.+ *+ * @return The builder instance+ */+ fun setMaxBuffers(@IntRange(from = 1, to = 64) numBuffers: Int): Builder {+ require(numBuffers > 0) { "Must have at least 1 buffer" }+ mMaxBuffers = numBuffers+ return this+ }++ /**+ * Specify the usage flags to be configured on the underlying [HardwareBuffer] instances+ * created by the [CanvasBufferedRenderer].+ *+ * @param usageFlags Usage flags to be configured on the created [HardwareBuffer] instances+ * that the [CanvasBufferedRenderer] will render into. Must be one of+ * [HardwareBufferUsage]. Note that the provided flags here are combined with the following+ * mandatory default flags,+ * [HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE], [HardwareBuffer.USAGE_GPU_COLOR_OUTPUT] and+ * [HardwareBuffer.USAGE_COMPOSER_OVERLAY]+ *+ * @return The builder instance+ */+ fun setUsageFlags(@HardwareBufferUsage usageFlags: Long): Builder {+ mUsageFlags = usageFlags or DefaultFlags+ return this+ }++ /**+ * Internal test method use to verify alternative implementations of+ * HardwareBufferRenderer.Impl as well as internal algorithms for+ * persisting rendered content+ */+ internal fun setImpl(impl: Int): Builder {+ mImpl = impl+ return this+ }++ /**+ * Create the [CanvasBufferedRenderer] with the specified parameters on+ * this [Builder] instance.+ *+ * @return The newly created [CanvasBufferedRenderer] instance.+ */+ fun build(): CanvasBufferedRenderer {+ return CanvasBufferedRenderer(+ width,+ height,+ mBufferFormat,+ mUsageFlags,+ mMaxBuffers,+ mImpl+ )+ }+ }++ /**+ * Sets the parameters that can be used to control a render request for a+ * [CanvasBufferedRenderer]. This is not thread-safe and must not be held on to for longer+ * than a single request.+ */+ inner class RenderRequest internal constructor() {++ private var mColorSpace = DefaultColorSpace+ private var mTransform = SurfaceControlCompat.BUFFER_TRANSFORM_IDENTITY+ private var mPreserveContents = false++ internal val preserveContents: Boolean+ get() = mPreserveContents++ internal val colorSpace: ColorSpace+ get() = mColorSpace++ internal val transform: Int+ get() = mTransform++ internal fun reset() {+ mColorSpace = DefaultColorSpace+ mTransform = SurfaceControlCompat.BUFFER_TRANSFORM_IDENTITY+ mPreserveContents = false+ }++ /**+ * Syncs the [RenderNode] tree to the render thread and requests content to be drawn.+ * This [RenderRequest] instance should no longer be used after calling this method.+ * The system internally may reuse instances of [RenderRequest] to reduce allocation churn.+ *+ * @throws IllegalStateException if this method is invoked after the+ * [CanvasBufferedRenderer] has been closed.+ */+ fun draw(executor: Executor, callback: Consumer) {+ if (isClosed()) {+ throw IllegalStateException("Attempt to draw after renderer has been closed")+ }+ mImpl.draw(this, executor, callback)+ }++ /**+ * Specifies a transform to be applied before content is rendered. This is useful+ * for pre-rotating content for the current display orientation to increase performance+ * of displaying the associated buffer. This transformation will also adjust the light+ * source position for the specified rotation.+ * @see SurfaceControl.Transaction#setBufferTransform(SurfaceControl, int)+ *+ * @throws IllegalArgumentException if [bufferTransform] is not one of:+ * [SurfaceControlCompat.BUFFER_TRANSFORM_IDENTITY],+ * [SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_90],+ * [SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_180], or+ * [SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_270]+ */+ fun setBufferTransform(@BufferTransform bufferTransform: Int): RenderRequest {+ val validTransform =+ bufferTransform == SurfaceControlCompat.BUFFER_TRANSFORM_IDENTITY ||+ bufferTransform == SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_90 ||+ bufferTransform == SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_180 ||+ bufferTransform == SurfaceControlCompat.BUFFER_TRANSFORM_ROTATE_270+ if (validTransform) {+ mTransform = bufferTransform+ } else {+ throw IllegalArgumentException(+ "Invalid transform provided, must be one of the " ++ "SurfaceControlCompat.BufferTransform values received: " + bufferTransform+ )+ }+ return this+ }++ /**+ * Configures the color space which the content should be rendered in. This affects how the+ * framework will interpret the color at each pixel. The color space provided here must be+ * non-null, RGB based and leverage an ICC parametric curve. The min/max values of the+ * components should not reduce the numerical range compared to the previously assigned+ * color space. If left unspecified, the default color space of SRGB will be used.+ *+ * **NOTE** this method is only supported on Android U and above and is ignored on older+ * Android versions+ */+ fun setColorSpace(colorSpace: ColorSpace?): RenderRequest {+ mColorSpace = colorSpace ?: DefaultColorSpace+ return this+ }++ /**+ * Determines whether or not previous buffer contents will be persisted across render+ * requests. If false then contents are cleared before issuing drawing instructions,+ * otherwise contents will remain. If contents are known in advance to be completely opaque+ * and cover all pixels within the buffer, setting this flag to false will slightly improve+ * performance as the clear operation will be skipped. Additionally for single buffered+ * rendering scenarios, persisting contents can be beneficial in order to draw the deltas of+ * content across frames. The default setting is false+ */+ fun preserveContents(preserve: Boolean): RenderRequest {+ mPreserveContents = preserve+ return this+ }+ }++ /**+ * Releases the [HardwareBuffer] back into the allocation pool to be reused in subsequent+ * renders. The [HardwareBuffer] instance released here must be one that was originally obtained+ * from this [CanvasBufferedRenderer] instance. This method also takes in an optional+ * [SyncFenceCompat] instance that will be internally waited upon before re-using the buffer.+ * This is useful in conjunction with [SurfaceControlCompat.Transaction.setBuffer] where the+ * system will return a release fence that should be waited upon before the corresponding buffer+ * can be re-used.+ *+ * @param hardwareBuffer [HardwareBuffer] to return back to the allocation pool+ * @param fence Optional [SyncFenceCompat] that should be waited upon before the buffer is+ * reused.+ */+ fun releaseBuffer(hardwareBuffer: HardwareBuffer, fence: SyncFenceCompat?) {+ mImpl.releaseBuffer(hardwareBuffer, fence)+ }++ /**+ * Class that contains data regarding the result of the render request. Consumers are to wait+ * on the provided [SyncFenceCompat] before consuming the [HardwareBuffer] provided to as well+ * as verify that the status returned by [RenderResult.status] returns [RenderResult.SUCCESS].+ */+ class RenderResult(+ private val buffer: HardwareBuffer,+ private val mFence: SyncFenceCompat?,+ private val mStatus: Int+ ) {++ /**+ * [HardwareBuffer] that contains the result of the render request.+ * Consumers should be sure to block on the [SyncFenceCompat] instance+ * provided in [fence] before consuming the contents of this buffer.+ */+ val hardwareBuffer: HardwareBuffer+ get() = buffer++ /**+ * Optional fence that should be waited upon before consuming [hardwareBuffer]+ */+ val fence: SyncFenceCompat?+ get() = mFence++ /**+ * Status code for the [RenderResult] either [SUCCESS] if rendering completed or+ * [ERROR_UNKNOWN] if the rendering could not be completed.+ */+ val status: Int+ get() = mStatus++ companion object {+ /**+ * Render request was completed successfully+ */+ const val SUCCESS = 0++ /**+ * Render request failed with an unknown error+ */+ const val ERROR_UNKNOWN = 1+ }+ }++ internal interface Impl : AutoCloseable {++ override fun close()++ fun isClosed(): Boolean++ fun draw(+ request: RenderRequest,+ executor: Executor,+ callback: Consumer+ )++ fun releaseBuffer(hardwareBuffer: HardwareBuffer, syncFence: SyncFenceCompat?)++ fun setContentRoot(renderNode: RenderNode)++ fun setLightSourceAlpha(+ ambientShadowAlpha: Float,+ spotShadowAlpha: Float,+ )++ fun setLightSourceGeometry(+ lightX: Float,+ lightY: Float,+ lightZ: Float,+ lightRadius: Float+ )+ }++ internal companion object {++ val DefaultColorSpace = ColorSpace.get(ColorSpace.Named.SRGB)++ /**+ * Test flag to use the optimal implementation for the corresponding+ * Android platform version+ */+ internal const val DEFAULT_IMPL = 0++ /**+ * Test flag used to verify the V29 implementation that leverages the+ * redraw strategy on devices that do not persist contents of opaque renders+ */+ internal const val USE_V29_IMPL_WITH_REDRAW = 1++ /**+ * Test flag used to verify the V29 implementation that leverages the default+ * single buffered restoration strategy+ */+ internal const val USE_V29_IMPL_WITH_SINGLE_BUFFER = 2+ }+}
@@ -0,0 +1,408 @@
+/*+ * Copyright 2023 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 androidx.graphics++import android.graphics.Bitmap+import android.graphics.BlendMode+import android.graphics.Canvas+import android.graphics.Color+import android.graphics.HardwareRenderer+import android.graphics.Matrix+import android.graphics.RenderNode+import android.hardware.HardwareBuffer+import android.media.Image+import android.media.ImageReader+import android.os.Build+import android.util.Log+import androidx.annotation.RequiresApi+import androidx.core.util.Consumer+import androidx.graphics.CanvasBufferedRenderer.RenderResult.Companion.ERROR_UNKNOWN+import androidx.graphics.CanvasBufferedRenderer.RenderResult.Companion.SUCCESS+import androidx.graphics.lowlatency.BufferTransformHintResolver+import androidx.graphics.lowlatency.PreservedBufferContentsVerifier+import androidx.hardware.SyncFenceCompat+import androidx.hardware.SyncFenceV33+import java.util.concurrent.Executor+import java.util.concurrent.locks.ReentrantLock+import kotlin.concurrent.withLock++@RequiresApi(Build.VERSION_CODES.Q)+internal class CanvasBufferedRendererV29(+ private val mWidth: Int,+ private val mHeight: Int,+ format: Int,+ usage: Long,+ private val mMaxBuffers: Int,+ preservationStrategy: Int,+) : CanvasBufferedRenderer.Impl {++ private val mPreservedRenderStrategy = createPreservationStrategy(preservationStrategy)++ private val mImageReader = ImageReader.newInstance(+ mWidth,+ mHeight,+ format,+ // If the device does not support preserving contents when we are rendering to a single+ // buffer, use the fallback of leveraging 2 but redrawing the contents from the previous+ // frame into the next frame+ if (mMaxBuffers == 1) mPreservedRenderStrategy.maxImages else mMaxBuffers,+ usage+ )++ private val mRootRenderNode = RenderNode("rootNode").apply {+ setPosition(0, 0, mWidth, mHeight)+ clipToBounds = false+ }++ private var mContentRoot: RenderNode? = null++ private var mBufferTransform = BufferTransformHintResolver.UNKNOWN_TRANSFORM+ private val mTransform = Matrix()++ private var mPreserveContents = false++ /**+ * Lock used to provide thread safe access to the underlying pool that maps between outstanding+ * HardwareBuffer instances and the Image it is associated with+ */+ private val mBufferLock = ReentrantLock()++ /**+ * Condition used to signal when an Image is available after it was previously released+ */+ private val mBufferSignal = mBufferLock.newCondition()++ /**+ * Mapping of [HardwareBuffer] instances to the corresponding [Image] they are associated with.+ * Because [ImageReader] allocates a new [Image] instance each time acquireNextImage is called,+ * we cannot rely on the fact that the [ImageReader] will cycle through the same [Image]+ * instances. So instead create a mapping of buffers to Images that will be added to and removed+ * on each render.+ */+ private val mAllocatedBuffers = HashMap()++ private var mHardwareRenderer: HardwareRenderer? = HardwareRenderer().apply {+ // HardwareRenderer will preserve contents of the buffers if the isOpaque flag is true+ // otherwise it will clear contents across subsequent renders+ isOpaque = true+ setContentRoot(mRootRenderNode)+ setSurface(mImageReader.surface)+ start()+ }++ private fun closeBuffers() = mBufferLock.withLock {+ for (entry in mAllocatedBuffers) {+ entry.key.close() // HardwareBuffer+ entry.value.waitAndClose() // Image+ }+ mAllocatedBuffers.clear()+ mBufferSignal.signal()+ }++ override fun close() {+ closeBuffers()+ mImageReader.close()+ mHardwareRenderer?.let { renderer ->+ renderer.stop()+ renderer.destroy()+ }+ mHardwareRenderer = null+ mRootRenderNode.discardDisplayList()+ }++ override fun isClosed(): Boolean = mHardwareRenderer == null++ override fun draw(+ request: CanvasBufferedRenderer.RenderRequest,+ executor: Executor,+ callback: Consumer+ ) {+ val transform = request.transform+ val content = mContentRoot+ // If we are redrawing contents from the previous scene then we must re-record the drawing+ // drawing instructions to draw the updated bitmap+ val forceRedraw = request.preserveContents || mPreserveContents+ val shouldRedraw = !mRootRenderNode.hasDisplayList() || transform != mBufferTransform ||+ forceRedraw+ if (shouldRedraw && content != null) {+ recordContent(content, updateTransform(transform), request.preserveContents)+ }++ val renderer = mHardwareRenderer+ if (renderer != null && !isClosed()) {+ with(renderer) {+ var result = 0+ val renderRequest = createRenderRequest()+ .setFrameCommitCallback(executor) {+ acquireBuffer { buffer, fence ->+ executor.execute {+ mPreservedRenderStrategy.onRenderComplete(buffer, fence)+ callback.accept(+ CanvasBufferedRenderer.RenderResult(+ buffer,+ fence,+ if (result != 0) ERROR_UNKNOWN else SUCCESS+ )+ )+ if (mMaxBuffers == 1) {+ releaseBuffer(buffer, fence)+ }+ }+ }+ }+ result = renderRequest.syncAndDraw()+ }+ } else {+ Log.v(TAG, "mHardwareRenderer is null")+ }+ }++ private fun updateTransform(transform: Int): Matrix {+ mBufferTransform = transform+ return BufferTransformHintResolver.configureTransformMatrix(+ mTransform,+ mWidth.toFloat(),+ mHeight.toFloat(),+ transform+ )+ }++ private fun recordContent(+ contentNode: RenderNode,+ transform: Matrix,+ preserveContents: Boolean+ ) {+ val canvas = mRootRenderNode.beginRecording()+ if (preserveContents) {+ mPreservedRenderStrategy.restoreContents(canvas)+ } else {+ canvas.drawColor(Color.BLACK, BlendMode.CLEAR)+ }+ canvas.save()+ canvas.concat(transform)+ canvas.drawRenderNode(contentNode)+ canvas.restore()+ mRootRenderNode.endRecording()+ mPreserveContents = preserveContents+ }++ override fun setContentRoot(renderNode: RenderNode) {+ mContentRoot = renderNode+ mRootRenderNode.discardDisplayList()+ }++ override fun setLightSourceAlpha(ambientShadowAlpha: Float, spotShadowAlpha: Float) {+ mHardwareRenderer?.setLightSourceAlpha(ambientShadowAlpha, spotShadowAlpha)+ }++ /**+ * Acquires the next [Image] from the [ImageReader]. This method will block until the+ * number of outstanding [Image]s acquired is below the maximum number of buffers specified+ * by maxImages. This is because [ImageReader] will throw exceptions if an additional+ * [Image] is acquired beyond the maximum amount of buffers.+ */+ private inline fun acquireBuffer(block: (HardwareBuffer, SyncFenceCompat?) -> Unit) {+ mBufferLock.withLock {+ // Block until the number of outstanding Images is less than the maximum specified+ while (mAllocatedBuffers.size >= mImageReader.maxImages) {+ mBufferSignal.await()+ }+ val image = mImageReader.acquireNextImage()+ if (image != null) {+ // Be sure to call Image#getHardwareBuffer once as each call creates a new java object+ // and we are relying on referential equality to map the HardwareBuffer back to the+ // Image that it came from in order to close the Image when the buffer is released+ val buffer = image.hardwareBuffer+ if (buffer != null) {+ // Insert a new mapping of hardware buffer to Image, closing any previous Image+ // that maybe inserted for the hardware buffer+ mAllocatedBuffers.put(buffer, image)?.waitAndClose()+ val fence = image.getFenceCompat()+ block(buffer, fence)+ // If we are leveraging single buffered rendering, release the buffer right away+ if (mImageReader.maxImages == 1) {+ releaseBuffer(buffer, fence)+ }+ } else {+ // If we do not have a HardwareBuffer associated with this Image, close it+ // and return null+ image.waitAndClose()+ }+ }+ }+ }++ override fun releaseBuffer(hardwareBuffer: HardwareBuffer, syncFence: SyncFenceCompat?) {+ mBufferLock.withLock {+ // Remove the mapping of HardwareBuffer to Image and close the Image associated with+ // this HardwareBuffer instance+ val image = mAllocatedBuffers.remove(hardwareBuffer)+ if (image != null) {+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {+ ImageVerificationHelper.setFence(image, syncFence)+ image.close()+ } else {+ image.waitAndClose()+ }+ }+ mBufferSignal.signal()+ }+ }++ override fun setLightSourceGeometry(+ lightX: Float,+ lightY: Float,+ lightZ: Float,+ lightRadius: Float+ ) {+ mHardwareRenderer?.setLightSourceGeometry(lightX, lightY, lightZ, lightRadius)+ }++ private fun Image.getFenceCompat(): SyncFenceCompat? =+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {+ ImageVerificationHelper.getFence(this)+ } else {+ null+ }++ private fun Image.waitAndClose() {+ getFenceCompat()?.let { fence ->+ fence.awaitForever()+ fence.close()+ }+ close()+ }++ internal interface PreservedRenderStrategy {+ val maxImages: Int++ fun restoreContents(canvas: Canvas)++ fun onRenderComplete(+ hardwareBuffer: HardwareBuffer,+ fence: SyncFenceCompat?+ )+ }++ internal class SingleBufferedStrategy : PreservedRenderStrategy {+ override val maxImages = 1++ override fun restoreContents(canvas: Canvas) {+ // NO-OP HWUI preserves contents+ }++ override fun onRenderComplete(+ hardwareBuffer: HardwareBuffer,+ fence: SyncFenceCompat?+ ) {+ // NO-OP+ }+ }++ internal class RedrawBufferStrategy(+ // debugging flag used to simulate clearing of the canvas before+ // restoring the contents+ private val forceClear: Boolean = false+ ) : PreservedRenderStrategy {++ override val maxImages: Int = 2++ private var mHardwareBuffer: HardwareBuffer? = null+ private var mFence: SyncFenceCompat? = null++ override fun restoreContents(canvas: Canvas) {+ if (forceClear) {+ canvas.drawColor(Color.BLACK, BlendMode.CLEAR)+ }+ mHardwareBuffer?.let { buffer ->+ mFence?.awaitForever()+ val bitmap = Bitmap.wrapHardwareBuffer(+ buffer,+ CanvasBufferedRenderer.DefaultColorSpace+ )+ if (bitmap != null) {+ canvas.save()+ canvas.drawBitmap(bitmap, 0f, 0f, null)+ canvas.restore()+ }+ }+ }++ override fun onRenderComplete(+ hardwareBuffer: HardwareBuffer,+ fence: SyncFenceCompat?+ ) {+ mHardwareBuffer = hardwareBuffer+ mFence = fence+ }+ }++ companion object {+ const val TAG = "BufferRendererV29"++ internal fun createPreservationStrategy(+ preservationStrategy: Int+ ): PreservedRenderStrategy =+ when (preservationStrategy) {+ CanvasBufferedRenderer.USE_V29_IMPL_WITH_SINGLE_BUFFER -> {+ Log.v(TAG, "Explicit usage of single buffered preservation strategy")+ SingleBufferedStrategy()+ }+ CanvasBufferedRenderer.USE_V29_IMPL_WITH_REDRAW -> {+ Log.v(TAG, "Explicit usage of double buffered redraw strategy " ++ "with force clear")+ RedrawBufferStrategy(true)+ }+ else -> {+ val verifier = PreservedBufferContentsVerifier()+ val preserveContents = verifier.supportsPreservedRenderedContent()+ verifier.release()+ if (preserveContents) {+ Log.v(TAG, "Device supports persisted canvas optimizations")+ SingleBufferedStrategy()+ } else {+ Log.w(+ TAG,+ "Warning, device DOES NOT support persisted canvas optimizations."+ )+ RedrawBufferStrategy(false)+ }+ }+ }+ }+}++/**+ * Helper class to avoid class verification failures+ */+@RequiresApi(Build.VERSION_CODES.TIRAMISU)+internal class ImageVerificationHelper private constructor() {+ companion object {++ @RequiresApi(Build.VERSION_CODES.TIRAMISU)+ @androidx.annotation.DoNotInline+ fun getFence(image: Image): SyncFenceCompat = SyncFenceCompat(image.fence)++ @RequiresApi(Build.VERSION_CODES.TIRAMISU)+ @androidx.annotation.DoNotInline+ fun setFence(image: Image, fence: SyncFenceCompat?) {+ if (fence != null && fence.mImpl is SyncFenceV33) {+ image.fence = fence.mImpl.mSyncFence+ }+ }+ }+}
@@ -1,469 +0,0 @@
-/*- * Copyright 2023 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 androidx.graphics--import android.annotation.SuppressLint-import android.graphics.BlendMode-import android.graphics.Canvas-import android.graphics.Color-import android.graphics.ColorSpace-import android.graphics.HardwareBufferRenderer-import android.graphics.HardwareRenderer-import android.graphics.PixelFormat-import android.graphics.RenderNode-import android.hardware.HardwareBuffer-import android.media.Image-import android.media.ImageReader-import android.os.Build-import android.util.Log-import androidx.annotation.RequiresApi-import androidx.graphics.BufferedRendererImpl.Companion.DefaultColorSpace-import androidx.graphics.lowlatency.BufferTransformHintResolver-import androidx.graphics.lowlatency.BufferTransformer-import androidx.hardware.BufferPool-import androidx.hardware.SyncFenceCompat-import androidx.hardware.SyncFenceV33-import java.util.concurrent.Executor-import java.util.concurrent.atomic.AtomicBoolean-import java.util.concurrent.atomic.AtomicReference-import java.util.concurrent.locks.ReentrantLock-import kotlin.concurrent.withLock--@RequiresApi(Build.VERSION_CODES.Q)-internal fun defaultBufferTransformer(width: Int, height: Int) =- BufferTransformer().apply {- computeTransform(width, height, BufferTransformHintResolver.UNKNOWN_TRANSFORM)- }--/**- * Helper class used to draw RenderNode content into a HardwareBuffer instance. The contents of the- * HardwareBuffer are not persisted across renders.- */-@RequiresApi(Build.VERSION_CODES.Q)-internal class MultiBufferedCanvasRenderer(- width: Int,- height: Int,- bufferTransformer: BufferTransformer = defaultBufferTransformer(width, height),- format: Int = PixelFormat.RGBA_8888,- usage: Long = HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or HardwareBuffer.USAGE_GPU_COLOR_OUTPUT,- maxImages: Int = 3-) {-- private val mBufferRenderer: BufferedRendererImpl =- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {- BufferedRendererV34(- width,- height,- bufferTransformer,- format,- usage,- maxImages- )- } else {- BufferedRendererV29(- bufferTransformer,- format,- usage,- maxImages- )- }-- private val mPreserveContents = AtomicBoolean(false)-- var preserveContents: Boolean- get() = mPreserveContents.get()- set(value) { mPreserveContents.set(value) }-- private var mIsReleased = false-- inline fun record(block: (canvas: Canvas) -> Unit) {- val canvas = mBufferRenderer.beginRecording()- if (!preserveContents) {- canvas.drawColor(Color.BLACK, BlendMode.CLEAR)- }- block(canvas)- mBufferRenderer.endRecording()- }-- var colorSpace: ColorSpace- get() = mBufferRenderer.colorSpace- set(value) { mBufferRenderer.colorSpace = value }-- fun renderFrame(- executor: Executor,- bufferAvailable: (HardwareBuffer, SyncFenceCompat?) -> Unit- ) {- if (!mIsReleased) {- mBufferRenderer.renderFrame(executor, bufferAvailable)- }- }-- /**- * Release the buffer and close the corresponding [Image] instance to allow for the buffer- * to be re-used on a subsequent render- */- fun releaseBuffer(hardwareBuffer: HardwareBuffer, fence: SyncFenceCompat?) {- mBufferRenderer.releaseBuffer(hardwareBuffer, fence)- }-- fun release() {- if (!mIsReleased) {- mBufferRenderer.release()- mIsReleased = true- }- }-- internal companion object {- const val TAG = "MultiBufferRenderer"- }-}--@RequiresApi(Build.VERSION_CODES.Q)-internal interface BufferedRendererImpl {-- fun beginRecording(): Canvas-- fun endRecording()-- fun renderFrame(executor: Executor, bufferAvailable: (HardwareBuffer, SyncFenceCompat?) -> Unit)-- fun releaseBuffer(hardwareBuffer: HardwareBuffer, fence: SyncFenceCompat?)-- var colorSpace: ColorSpace- get() = DefaultColorSpace- set(_) {}-- fun release()-- val isReleased: Boolean-- companion object {- val DefaultColorSpace = ColorSpace.get(ColorSpace.Named.SRGB)- }-}--@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)-private class BufferedRendererV34(- val width: Int,- val height: Int,- val bufferTransformer: BufferTransformer,- val format: Int,- val usage: Long,- maxImages: Int-) : BufferedRendererImpl {-- private val mRenderNode = RenderNode("node").apply {- setPosition(- 0,- 0,- [email protected],- [email protected]- )- }-- private val mColorSpaceRef = AtomicReference(DefaultColorSpace)-- private data class HardwareBufferProvider(- private val buffer: HardwareBuffer,- val renderer: HardwareBufferRenderer- ) : BufferPool.BufferProvider {- override val hardwareBuffer: HardwareBuffer- get() = buffer-- override fun release() {- renderer.close()- buffer.close()- }- }-- private val mInverseTransform =- bufferTransformer.invertBufferTransform(bufferTransformer.computedTransform)-- private val mPool = BufferPool(maxImages)-- private fun obtainBufferEntry(): HardwareBufferProvider =- mPool.obtain {- val hardwareBuffer = HardwareBuffer.create(- bufferTransformer.glWidth,- bufferTransformer.glHeight,- format,- 1,- usage- )- val renderer = HardwareBufferRenderer(hardwareBuffer).apply {- setContentRoot(mRenderNode)- }- HardwareBufferProvider(hardwareBuffer, renderer)- }-- override fun beginRecording(): Canvas = mRenderNode.beginRecording()-- override fun endRecording() {- mRenderNode.endRecording()- }-- override val isReleased: Boolean- get() = mPool.isClosed-- override fun renderFrame(- executor: Executor,- bufferAvailable: (HardwareBuffer, SyncFenceCompat?) -> Unit- ) {- executor.execute {- val entry = obtainBufferEntry()- entry.renderer.obtainRenderRequest().apply {- setColorSpace(colorSpace)- if (mInverseTransform != BufferTransformHintResolver.UNKNOWN_TRANSFORM) {- setBufferTransform(mInverseTransform)- }- }.draw(executor) { result ->- bufferAvailable(entry.hardwareBuffer, SyncFenceCompat(result.fence))- }- }- }-- override var colorSpace: ColorSpace- get() = mColorSpaceRef.get()- set(value) { mColorSpaceRef.set(value) }-- override fun releaseBuffer(hardwareBuffer: HardwareBuffer, fence: SyncFenceCompat?) {- mPool.release(hardwareBuffer, fence)- }-- override fun release() {- mPool.close()- mRenderNode.discardDisplayList()- }-}--@RequiresApi(Build.VERSION_CODES.Q)-private class BufferedRendererV29(- bufferTransformer: BufferTransformer,- format: Int,- usage: Long,- maxImages: Int-) : BufferedRendererImpl {-- private val mRenderNode = RenderNode("renderNode").apply {- setPosition(- 0,- 0,- bufferTransformer.glWidth,- bufferTransformer.glHeight- )- }-- private val mTransform = android.graphics.Matrix().apply {- bufferTransformer.configureMatrix(this)- }-- // PixelFormat.RGBA_8888 should be accepted here but Android Studio flags as a warning- @SuppressLint("WrongConstant")- private val mImageReader = ImageReader.newInstance(- bufferTransformer.glWidth,- bufferTransformer.glHeight,- format,- maxImages,- usage- )- private var mHardwareRenderer: HardwareRenderer? = HardwareRenderer().apply {- // HardwareRenderer will preserve contents of the buffers if the isOpaque flag is true- // otherwise it will clear contents across subsequent renders- isOpaque = true- setContentRoot(mRenderNode)- setSurface(mImageReader.surface)- start()- }-- /**- * Lock used to provide thread safe access to the underlying pool that maps between outstanding- * HardwareBuffer instances and the Image it is associated with- */- private val mBufferLock = ReentrantLock()-- /**- * Condition used to signal when an Image is available after it was previously released- */- private val mBufferSignal = mBufferLock.newCondition()-- /**- * Mapping of [HardwareBuffer] instances to the corresponding [Image] they are associated with.- * Because [ImageReader] allocates a new [Image] instance each time acquireNextImage is called,- * we cannot rely on the fact that the [ImageReader] will cycle through the same [Image]- * instances. So instead create a mapping of buffers to Images that will be added to and removed- * on each render.- */- private val mAllocatedBuffers = HashMap()-- override val isReleased: Boolean- get() = mHardwareRenderer == null-- private var mCanvas: Canvas? = null-- override fun beginRecording(): Canvas {- val canvas = mRenderNode.beginRecording()- canvas.save()- canvas.setMatrix(mTransform)- mCanvas = canvas- return canvas- }-- override fun endRecording() {- mCanvas?.restore()- mRenderNode.endRecording()- }-- override fun renderFrame(- executor: Executor,- bufferAvailable: (HardwareBuffer, SyncFenceCompat?) -> Unit- ) {- val renderer = mHardwareRenderer- if (renderer != null && !isReleased) {- with(renderer) {- createRenderRequest()- .setFrameCommitCallback(executor) {- acquireBuffer { buffer, fence ->- executor.execute {- bufferAvailable(buffer, fence)- }- }- }- .syncAndDraw()- }- } else {- Log.v(TAG, "mHardwareRenderer is null")- }- }-- /**- * Acquires the next [Image] from the [ImageReader]. This method will block until the- * number of outstanding [Image]s acquired is below the maximum number of buffers specified- * by maxImages. This is because [ImageReader] will throw exceptions if an additional- * [Image] is acquired beyond the maximum amount of buffers.- */- private inline fun acquireBuffer(block: (HardwareBuffer, SyncFenceCompat?) -> Unit) {- mBufferLock.withLock {- // Block until the number of outstanding Images is less than the maximum specified- while (mAllocatedBuffers.size >= mImageReader.maxImages) {- mBufferSignal.await()- }- val image = mImageReader.acquireNextImage()- if (image != null) {- // Be sure to call Image#getHardwareBuffer once as each call creates a new java object- // and we are relying on referential equality to map the HardwareBuffer back to the- // Image that it came from in order to close the Image when the buffer is released- val buffer = image.hardwareBuffer- if (buffer != null) {- // Insert a new mapping of hardware buffer to Image, closing any previous Image- // that maybe inserted for the hardware buffer- mAllocatedBuffers.put(buffer, image)?.waitAndClose()- val fence = image.getFenceCompat()- block(buffer, fence)- // If we are leveraging single buffered rendering, release the buffer right away- if (mImageReader.maxImages == 1) {- releaseBuffer(buffer, fence)- }- } else {- // If we do not have a HardwareBuffer associated with this Image, close it- // and return null- image.waitAndClose()- }- }- }- }-- private fun Image.getFenceCompat(): SyncFenceCompat? =- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {- ImageVerificationHelper.getFence(this)- } else {- null- }-- private fun Image.waitAndClose() {- getFenceCompat()?.let { fence ->- fence.awaitForever()- fence.close()- }- close()- }-- /**- * Release the buffer and close the corresponding [Image] instance to allow for the buffer- * to be re-used on a subsequent render- */- override fun releaseBuffer(hardwareBuffer: HardwareBuffer, fence: SyncFenceCompat?) {- mBufferLock.withLock {- // Remove the mapping of HardwareBuffer to Image and close the Image associated with- // this HardwareBuffer instance- val image = mAllocatedBuffers.remove(hardwareBuffer)- if (image != null) {- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {- ImageVerificationHelper.setFence(image, fence)- image.close()- } else {- image.waitAndClose()- }- }- mBufferSignal.signal()- }- }-- private fun closeBuffers() = mBufferLock.withLock {- for (entry in mAllocatedBuffers) {- entry.key.close() // HardwareBuffer- entry.value.waitAndClose() // Image- }- mAllocatedBuffers.clear()- mBufferSignal.signal()- }-- override fun release() {- closeBuffers()- mImageReader.close()- mHardwareRenderer?.let { renderer ->- renderer.stop()- renderer.destroy()- }- mHardwareRenderer = null- mRenderNode.discardDisplayList()- }-- private companion object {- const val TAG = "BufferedRendererV29"- }-}--/**- * Helper class to avoid class verification failures- */-@RequiresApi(Build.VERSION_CODES.TIRAMISU)-internal class ImageVerificationHelper private constructor() {- companion object {-- @RequiresApi(Build.VERSION_CODES.TIRAMISU)- @androidx.annotation.DoNotInline- fun getFence(image: Image): SyncFenceCompat = SyncFenceCompat(image.fence)-- @RequiresApi(Build.VERSION_CODES.TIRAMISU)- @androidx.annotation.DoNotInline- fun setFence(image: Image, fence: SyncFenceCompat?) {- if (fence != null && fence.mImpl is SyncFenceV33) {- image.fence = fence.mImpl.mSyncFence- }- }- }-}
@@ -21,6 +21,7 @@
import android.os.Build import androidx.annotation.RequiresApi import androidx.graphics.surface.SurfaceControlCompat+import androidx.hardware.USAGE_COMPOSER_OVERLAY internal class FrontBufferUtils private constructor() {@@ -28,17 +29,6 @@
internal const val TAG = "FrontBufferUtils"- // Leverage the same value as HardwareBuffer.USAGE_COMPOSER_OVERLAY.- // While this constant was introduced in the SDK in the Android T release, it has- // been available within the NDK as part of- // AHardwareBuffer_UsageFlags#AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY for quite some time.- // This flag is required for usage of ASurfaceTransaction#setBuffer- // Use a separate constant with the same value to avoid SDK warnings of accessing the- // newly added constant in the SDK.- // See:- // developer.android.com/ndk/reference/group/a-hardware-buffer#ahardwarebuffer_usageflags- private const val USAGE_COMPOSER_OVERLAY: Long = 2048L- /** * Flags that are expected to be supported on all [HardwareBuffer] instances */
@@ -32,6 +32,8 @@
import androidx.graphics.opengl.egl.EGLManager import androidx.graphics.opengl.egl.EGLSpec import androidx.graphics.surface.SurfaceControlCompat+import androidx.hardware.DefaultFlags+import androidx.hardware.DefaultNumBuffers import androidx.hardware.HardwareBufferFormat import androidx.hardware.HardwareBufferUsage import androidx.hardware.SyncFenceCompat@@ -277,8 +279,8 @@
inverseTransform: Int ) { val frameBufferPool = FrameBufferPool(- bufferTransformer.glWidth,- bufferTransformer.glHeight,+ bufferTransformer.bufferWidth,+ bufferTransformer.bufferHeight,[email protected], mUsage, mMaxBuffers@@ -373,8 +375,8 @@
private val height = bufferTransformer.logicalHeight private val bufferInfo = BufferInfo().apply {- this.width = bufferTransformer.glWidth- this.height = bufferTransformer.glHeight+ this.width = bufferTransformer.bufferWidth+ this.height = bufferTransformer.bufferHeight } override fun obtainFrameBuffer(egl: EGLSpec): FrameBuffer {@@ -834,22 +836,5 @@
internal companion object { internal val TAG = "GLFrameBufferRenderer"-- // Leverage the same value as HardwareBuffer.USAGE_COMPOSER_OVERLAY.- // While this constant was introduced in the SDK in the Android T release, it has- // been available within the NDK as part of- // AHardwareBuffer_UsageFlags#AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY for quite some time.- // This flag is required for usage of ASurfaceTransaction#setBuffer- // Use a separate constant with the same value to avoid SDK warnings of accessing the- // newly added constant in the SDK.- // See:- // developer.android.com/ndk/reference/group/a-hardware-buffer#ahardwarebuffer_usageflags- private const val USAGE_COMPOSER_OVERLAY: Long = 2048L-- internal const val DefaultFlags = HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or- HardwareBuffer.USAGE_GPU_COLOR_OUTPUT or- USAGE_COMPOSER_OVERLAY-- internal const val DefaultNumBuffers = 3 } }
@@ -16,6 +16,7 @@
package androidx.hardware+import android.hardware.HardwareBuffer import android.hardware.HardwareBuffer.BLOB import android.hardware.HardwareBuffer.DS_24UI8 import android.hardware.HardwareBuffer.DS_FP32UI8@@ -54,3 +55,20 @@
YCBCR_P010 ) annotation class HardwareBufferFormat++// Leverage the same value as HardwareBuffer.USAGE_COMPOSER_OVERLAY.+// While this constant was introduced in the SDK in the Android T release, it has+// been available within the NDK as part of+// AHardwareBuffer_UsageFlags#AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY for quite some time.+// This flag is required for usage of ASurfaceTransaction#setBuffer+// Use a separate constant with the same value to avoid SDK warnings of accessing the+// newly added constant in the SDK.+// See:+// developer.android.com/ndk/reference/group/a-hardware-buffer#ahardwarebuffer_usageflags+internal const val USAGE_COMPOSER_OVERLAY: Long = 2048L++internal const val DefaultFlags = HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE or+ HardwareBuffer.USAGE_GPU_COLOR_OUTPUT or+ USAGE_COMPOSER_OVERLAY++internal const val DefaultNumBuffers = 3
@@ -11,9 +11,7 @@
method public final void isAtMost(T? other); method public void isEquivalentAccordingToCompareTo(T? other); method public final void isGreaterThan(T? other);- method public final void isIn(com.google.common.collect.Range range); method public final void isLessThan(T? other);- method public final void isNotIn(com.google.common.collect.Range range); } public final class DoubleSubject extends androidx.kruth.ComparableSubject {
@@ -11,9 +11,7 @@
method public final void isAtMost(T? other); method public void isEquivalentAccordingToCompareTo(T? other); method public final void isGreaterThan(T? other);- method public final void isIn(com.google.common.collect.Range range); method public final void isLessThan(T? other);- method public final void isNotIn(com.google.common.collect.Range range); } public final class DoubleSubject extends androidx.kruth.ComparableSubject {
@@ -23,10 +23,11 @@
* * @param T the type of the object being tested by this [ComparableSubject] */-expect open class ComparableSubject> internal constructor(+open class ComparableSubject> internal constructor( actual: T?, metadata: FailureMetadata = FailureMetadata(),-) : Subject {+) : Subject(actual, metadata),+ PlatformComparableSubject by PlatformComparableSubjectImpl(actual, metadata) { /** * Checks that the subject is equivalent to [other] according to [Comparable.compareTo],@@ -34,93 +35,78 @@
* * **Note:** Do not use this method for checking object equality. Instead, use [isEqualTo]. */- open fun isEquivalentAccordingToCompareTo(other: T?)+ open fun isEquivalentAccordingToCompareTo(other: T?) {+ requireNonNull(actual)+ requireNonNull(other)++ if (actual.compareTo(other) != 0) {+ failWithActualInternal(fact("Expected value that sorts equal to", other))+ }+ } /** * Checks that the subject is greater than [other]. * * To check that the subject is greater than *or equal to* [other], use [isAtLeast]. */- fun isGreaterThan(other: T?)+ fun isGreaterThan(other: T?) {+ requireNonNull(actual)+ requireNonNull(other)++ if (actual <= other) {+ failWithActualInternal(fact("Expected to be greater than", other))+ }+ } /** * Checks that the subject is less than [other]. * * @throws NullPointerException if [actual] or [other] is `null`. */- fun isLessThan(other: T?)+ fun isLessThan(other: T?) {+ requireNonNull(actual) { "Expected to be less than $other, but was $actual" }+ requireNonNull(other) { "Expected to be less than $other, but was $actual" }++ if (actual >= other) {+ failWithActualInternal(fact("Expected to be less than", other))+ }+ } /** * Checks that the subject is less than or equal to [other]. * * @throws NullPointerException if [actual] or [other] is `null`. */- fun isAtMost(other: T?)+ fun isAtMost(other: T?) {+ requireNonNull(actual) { "Expected to be at most $other, but was $actual" }+ requireNonNull(other) { "Expected to be at most $other, but was $actual" }+ if (actual > other) {+ failWithActualInternal(fact("Expected to be at most", other))+ }+ } /** * Checks that the subject is greater than or equal to [other]. * * @throws NullPointerException if [actual] or [other] is `null`. */- fun isAtLeast(other: T?)-}--// TODO(KT-20427): Internal helpers to share impl between actuals, since there is not yet a way-// to share default impls from an expect class.--internal fun > ComparableSubject.isInImpl(range: ClosedRange) {- if (requireNonNull(actual) !in range) {- failWithoutActualInternal(fact("Expected to be in range", range))+ fun isAtLeast(other: T?) {+ requireNonNull(actual) { "Expected to be at least $other, but was $actual" }+ requireNonNull(other) { "Expected to be at least $other, but was $actual" }+ if (actual < other) {+ failWithActualInternal(fact("Expected to be at least", other))+ } } }-internal fun > ComparableSubject.isNotInImpl(range: ClosedRange) {- if (requireNonNull(actual) in range) {- failWithoutActualInternal(fact("Expected not to be in range", range))- }-}+/**+ * Platform-specific propositions for [Comparable] typed subjects.+ *+ * @param T the type of the object being tested by this [ComparableSubject]+ */+internal expect interface PlatformComparableSubject>-internal fun > ComparableSubject.isEquivalentAccordingToCompareToImpl(- other: T?-) {- requireNonNull(actual)- requireNonNull(other)-- if (actual.compareTo(other) != 0) {- failWithActualInternal(fact("Expected value that sorts equal to", other))- }-}--internal fun > ComparableSubject.isGreaterThanImpl(other: T?) {- requireNonNull(actual)- requireNonNull(other)-- if (actual <= other) {- failWithActualInternal(fact("Expected to be greater than", other))- }-}--internal fun > ComparableSubject.isLessThanImpl(other: T?) {- requireNonNull(actual) { "Expected to be less than $other, but was $actual" }- requireNonNull(other) { "Expected to be less than $other, but was $actual" }-- if (actual >= other) {- failWithActualInternal(fact("Expected to be less than", other))- }-}--internal fun > ComparableSubject.isAtMostImpl(other: T?) {- requireNonNull(actual) { "Expected to be at most $other, but was $actual" }- requireNonNull(other) { "Expected to be at most $other, but was $actual" }- if (actual > other) {- failWithActualInternal(fact("Expected to be at most", other))- }-}--internal fun > ComparableSubject.isAtLeastImpl(other: T?) {- requireNonNull(actual) { "Expected to be at least $other, but was $actual" }- requireNonNull(other) { "Expected to be at least $other, but was $actual" }- if (actual < other) {- failWithActualInternal(fact("Expected to be at least", other))- }-}+internal expect class PlatformComparableSubjectImpl>(+ actual: T?,+ metadata: FailureMetadata,+) : Subject, PlatformComparableSubject
@@ -20,72 +20,33 @@
import com.google.common.collect.Range /**- * Propositions for [Comparable] typed subjects.+ * Platform-specific propositions for [Comparable] typed subjects. * * @param T the type of the object being tested by this [ComparableSubject] */-actual open class ComparableSubject> internal actual constructor(- actual: T?,- metadata: FailureMetadata,-) : Subject(actual = actual, metadata = metadata) {+internal actual interface PlatformComparableSubject> { /** Checks that the subject is in [range]. */- fun isIn(range: Range) {+ fun isIn(range: Range)++ /** Checks that the subject is *not* in [range]. */+ fun isNotIn(range: Range)+}++internal actual class PlatformComparableSubjectImpl> actual constructor(+ actual: T?,+ metadata: FailureMetadata,+) : Subject(actual, metadata), PlatformComparableSubject {++ override fun isIn(range: Range) { if (requireNonNull(actual) !in range) { failWithoutActualInternal(fact("Expected to be in range", range)) } }- /** Checks that the subject is *not* in [range]. */- fun isNotIn(range: Range) {+ override fun isNotIn(range: Range) { if (requireNonNull(actual) in range) { failWithoutActualInternal(fact("Expected not to be in range", range)) } }-- /**- * Checks that the subject is equivalent to [other] according to [Comparable.compareTo],- * (i.e., checks that `a.comparesTo(b) == 0`).- *- * **Note:** Do not use this method for checking object equality. Instead, use [isEqualTo].- */- actual open fun isEquivalentAccordingToCompareTo(other: T?) {- isEquivalentAccordingToCompareToImpl(other)- }-- /**- * Checks that the subject is greater than [other].- *- * To check that the subject is greater than *or equal to* [other], use [isAtLeast].- */- actual fun isGreaterThan(other: T?) {- isGreaterThanImpl(other)- }-- /**- * Checks that the subject is less than [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isLessThan(other: T?) {- isLessThanImpl(other)- }-- /**- * Checks that the subject is less than or equal to [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isAtMost(other: T?) {- isAtMostImpl(other)- }-- /**- * Checks that the subject is greater than or equal to [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isAtLeast(other: T?) {- isAtLeastImpl(other)- } }
@@ -17,58 +17,13 @@
package androidx.kruth /**- * Propositions for [Comparable] typed subjects.+ * Platform-specific propositions for [Comparable] typed subjects. * * @param T the type of the object being tested by this [ComparableSubject] */-actual open class ComparableSubject> internal actual constructor(+internal actual interface PlatformComparableSubject>++internal actual class PlatformComparableSubjectImpl> actual constructor( actual: T?, metadata: FailureMetadata,-) : Subject(actual = actual, metadata = metadata) {-- /**- * Checks that the subject is equivalent to [other] according to [Comparable.compareTo],- * (i.e., checks that `a.comparesTo(b) == 0`).- *- * **Note:** Do not use this method for checking object equality. Instead, use [isEqualTo].- */- actual open fun isEquivalentAccordingToCompareTo(other: T?) {- isEquivalentAccordingToCompareToImpl(other)- }-- /**- * Checks that the subject is greater than [other].- *- * To check that the subject is greater than *or equal to* [other], use [isAtLeast].- */- actual fun isGreaterThan(other: T?) {- isGreaterThanImpl(other)- }-- /**- * Checks that the subject is less than [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isLessThan(other: T?) {- isLessThanImpl(other)- }-- /**- * Checks that the subject is less than or equal to [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isAtMost(other: T?) {- isAtMostImpl(other)- }-- /**- * Checks that the subject is greater than or equal to [other].- *- * @throws NullPointerException if [actual] or [other] is `null`.- */- actual fun isAtLeast(other: T?) {- isAtLeastImpl(other)- }-}+) : Subject(actual, metadata), PlatformComparableSubject
@@ -59,7 +59,7 @@
# Disallow resolving dependencies at configuration time, which is a slight performance problem android.dependencyResolutionAtConfigurationTime.disallow=true-android.suppressUnsupportedOptionWarnings=android.suppressUnsupportedOptionWarnings,android.dependencyResolutionAtConfigurationTime.disallow,android.experimental.lint.missingBaselineIsEmptyBaseline,android.lint.printStackTrace,android.lint.baselineOmitLineNumbers,android.experimental.disableCompileSdkChecks,android.overrideVersionCheck,android.r8.maxWorkers,android.experimental.privacysandboxsdk.enable,android.experimental.lint.reservedMemoryPerTask,android.experimental.privacysandboxsdk.requireServices+android.suppressUnsupportedOptionWarnings=android.suppressUnsupportedOptionWarnings,android.dependencyResolutionAtConfigurationTime.disallow,android.experimental.lint.missingBaselineIsEmptyBaseline,android.lint.printStackTrace,android.lint.baselineOmitLineNumbers,android.experimental.disableCompileSdkChecks,android.overrideVersionCheck,android.r8.maxWorkers,android.experimental.privacysandboxsdk.enable,android.experimental.lint.reservedMemoryPerTask # Workaround for b/162074215 android.includeDependencyInfoInApks=false
@@ -210,6 +210,11 @@
method public void setExpanded(boolean); property public final float expandProgress; property public final boolean expanded;+ field public static final androidx.wear.compose.foundation.ExpandableState.Companion Companion;+ }++ public static final class ExpandableState.Companion {+ method @androidx.compose.runtime.Composable public androidx.compose.runtime.saveable.Saver saver(androidx.compose.animation.core.AnimationSpec expandAnimationSpec, androidx.compose.animation.core.AnimationSpec collapseAnimationSpec); } @SuppressCompatibility @androidx.wear.compose.foundation.ExperimentalWearFoundationApi public final class ExpandableStateMapping {
@@ -210,6 +210,11 @@
method public void setExpanded(boolean); property public final float expandProgress; property public final boolean expanded;+ field public static final androidx.wear.compose.foundation.ExpandableState.Companion Companion;+ }++ public static final class ExpandableState.Companion {+ method @androidx.compose.runtime.Composable public androidx.compose.runtime.saveable.Saver saver(androidx.compose.animation.core.AnimationSpec expandAnimationSpec, androidx.compose.animation.core.AnimationSpec collapseAnimationSpec); } @SuppressCompatibility @androidx.wear.compose.foundation.ExperimentalWearFoundationApi public final class ExpandableStateMapping {
@@ -0,0 +1,28 @@
+/*+ * Copyright 2023 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.+ */++// VERSION: v0_32+// GENERATED CODE - DO NOT MODIFY BY HAND++package androidx.wear.compose.material3.tokens++import androidx.compose.ui.unit.dp++internal object ListHeaderTokens {+ val ContentColor = ColorSchemeKeyTokens.OnSurfaceVariant+ val ContentTypography = TypographyKeyTokens.TitleMedium+ val Height = 48.0.dp+}
@@ -0,0 +1,28 @@
+/*+ * Copyright 2023 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.+ */++// VERSION: v0_32+// GENERATED CODE - DO NOT MODIFY BY HAND++package androidx.wear.compose.material3.tokens++import androidx.compose.ui.unit.dp++internal object ListSubHeaderTokens {+ val ContentColor = ColorSchemeKeyTokens.OnBackground+ val ContentTypography = TypographyKeyTokens.TitleMedium+ val Height = 48.0.dp+}
@@ -37,7 +37,7 @@
import androidx.wear.compose.material.Text class ScrollActivity : ComponentActivity() {- private var itemHeightDp: Dp = 20.dp+ private var itemHeightDp: Dp = 60.dp private var defaultItemSpacingDp: Dp = 8.dp override fun onCreate(savedInstanceState: Bundle?) {@@ -62,7 +62,11 @@
.background(MaterialTheme.colors.surface) .fillMaxSize() ) {- Text(text = "Item $it", color = MaterialTheme.colors.onSurface)+ Text(+ modifier = Modifier.align(Alignment.Center),+ text = "Item $it",+ color = MaterialTheme.colors.onSurface+ ) } } }
diff --git a/wear/protolayout/protolayout-lint/build.gradle b/wear/protolayout/protolayout-lint/build.gradle
new file mode 100644
index 0000000..ded2b3d
--- /dev/null
+++ b/wear/protolayout/protolayout-lint/build.gradle
@@ -0,0 +1,42 @@
+/*+ * Copyright 2023 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.+ */++import androidx.build.LibraryType++plugins {+ id("AndroidXPlugin")+ id("kotlin")+}++dependencies {+ compileOnly(libs.androidLintMinApi)+ compileOnly(libs.kotlinStdlib)++ testImplementation(libs.kotlinStdlib)+ testImplementation(libs.kotlinReflect)+ testImplementation(libs.kotlinStdlibJdk8)+ testImplementation(libs.androidLint)+ testImplementation(libs.androidLintTests)+ testImplementation(libs.junit)+ testImplementation(libs.truth)+}++androidx {+ name = "ProtoLayout Lint Checks"+ type = LibraryType.LINT+ inceptionYear = "2023"+ description = "Lint checks for ProtoLayout API usage. The linter mainly enforces version checking for calling any non 1.0 API."+}
@@ -0,0 +1,37 @@
+/*+ * Copyright 2023 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 androidx.wear.protolayout.lint++import com.android.tools.lint.client.api.IssueRegistry+import com.android.tools.lint.client.api.Vendor+import com.android.tools.lint.detector.api.CURRENT_API+import com.android.tools.lint.detector.api.Issue++/**+ * Issue Registry containing ProtoLayout specific lint Issues.+ */+@Suppress("UnstableApiUsage")+class ProtoLayoutIssueRegistry : IssueRegistry() {+ override val api = 14+ override val minApi = CURRENT_API+ override val issues get() = emptyList()+ override val vendor = Vendor(+ feedbackUrl = "https://issuetracker.google.com/issues/new?component=1112273",+ identifier = "androidx.wear.protolayout",+ vendorName = "Android Open Source Project",+ )+}
@@ -880,7 +880,7 @@
@SuppressLint("MissingGetterMatchingBuilder") @NonNull public Builder setRtlAware(boolean rtlAware) {- return setRtlAware(new BoolProp.Builder().setValue(rtlAware).build());+ return setRtlAware(new BoolProp.Builder(rtlAware).build()); } /** Sets the padding for all sides of the content, in DP. */@@ -1423,6 +1423,24 @@
} }+ /**+ * Gets whether the attached element is hidden, or visible. If the element is hidden, then+ * it will still consume space in the layout, but will not render any contents, nor will any+ * children render any contents.+ *+ *
Note that a hidden element also cannot be clickable (i.e. a {@link Clickable} modifier
+ * would be ignored).+ */+ @ProtoLayoutExperimental+ @Nullable+ public BoolProp getHidden() {+ if (mImpl.hasHidden()) {+ return BoolProp.fromProto(mImpl.getHidden());+ } else {+ return null;+ }+ }+ /** Get the fingerprint for this object, or null if unknown. */ @RestrictTo(Scope.LIBRARY_GROUP) @Nullable@@ -1474,6 +1492,8 @@
+ getMetadata() + ", contentUpdateAnimation=" + getContentUpdateAnimation()+ + ", hidden="+ + getHidden() + "}"; }@@ -1572,6 +1592,26 @@
return this; }+ /**+ * Sets whether the attached element is hidden, or visible. If the element is hidden,+ * then it will still consume space in the layout, but will not render any contents, nor+ * will any children render any contents.+ *+ *
Note that a hidden element also cannot be clickable (i.e. a {@link Clickable}
+ * modifier would be ignored).+ *+ *
Defaults to false (i.e. not hidden).
+ */+ @RequiresSchemaVersion(major = 1, minor = 300)+ @ProtoLayoutExperimental+ @NonNull+ public Builder setHidden(@NonNull BoolProp hidden) {+ mImpl.setHidden(hidden.toProto());+ mFingerprint.recordPropertyUpdate(+ 8, checkNotNull(hidden.getFingerprint()).aggregateValueAsInt());+ return this;+ }+ /** Builds an instance from accumulated values. */ @NonNull public Modifiers build() {
@@ -25,6 +25,7 @@
import androidx.annotation.RestrictTo; import androidx.annotation.RestrictTo.Scope; import androidx.wear.protolayout.expression.DynamicBuilders;+import androidx.wear.protolayout.expression.DynamicBuilders.DynamicBool; import androidx.wear.protolayout.expression.DynamicBuilders.DynamicFloat; import androidx.wear.protolayout.expression.DynamicBuilders.DynamicString; import androidx.wear.protolayout.expression.Fingerprint;@@ -506,6 +507,21 @@
return mImpl.getValue(); }+ /**+ * Gets the dynamic value. Note that when setting this value, the static value is still+ * required to be set to support older renderers that only read the static value. If {@code+ * dynamicValue} has an invalid result, the provided static value will be used instead.+ */+ @RequiresSchemaVersion(major = 1, minor = 200)+ @Nullable+ public DynamicBool getDynamicValue() {+ if (mImpl.hasDynamicValue()) {+ return DynamicBuilders.dynamicBoolFromProto(mImpl.getDynamicValue());+ } else {+ return null;+ }+ }+ /** Get the fingerprint for this object, or null if unknown. */ @RestrictTo(Scope.LIBRARY_GROUP) @Nullable@@ -544,6 +560,20 @@
private final TypesProto.BoolProp.Builder mImpl = TypesProto.BoolProp.newBuilder(); private final Fingerprint mFingerprint = new Fingerprint(1691257528);+ /**+ * Creates an instance of {@link Builder} from the given static value. {@link+ * #setDynamicValue(DynamicBool)} can be used to provide a dynamic value.+ */+ public Builder(boolean staticValue) {+ setValue(staticValue);+ }++ /**+ * Creates an instance of {@link Builder}.+ *+ * @deprecated use {@link #Builder(boolean)}+ */+ @Deprecated public Builder() {} /** Sets the static value. */@@ -556,9 +586,33 @@
return this; }- /** Builds an instance from accumulated values. */+ /**+ * Sets the dynamic value. Note that when setting this value, the static value is still+ * required to be set to support older renderers that only read the static value. If+ * {@code dynamicValue} has an invalid result, the provided static value will be used+ * instead.+ */+ @RequiresSchemaVersion(major = 1, minor = 200)+ @NonNull+ public Builder setDynamicValue(@NonNull DynamicBool dynamicValue) {+ mImpl.setDynamicValue(dynamicValue.toDynamicBoolProto());+ mFingerprint.recordPropertyUpdate(+ 2, checkNotNull(dynamicValue.getFingerprint()).aggregateValueAsInt());+ return this;+ }++ /**+ * Builds an instance from accumulated values.+ *+ * @throws IllegalStateException if a dynamic value is set using {@link+ * #setDynamicValue(DynamicBool)} but neither {@link #Builder(boolean)} nor {@link+ * #setValue(boolean)} is used to provide a static value.+ */ @NonNull public BoolProp build() {+ if (mImpl.hasDynamicValue() && !mImpl.hasValue()) {+ throw new IllegalStateException("Static value is missing.");+ } return new BoolProp(mImpl.build(), mFingerprint); } }
