android-35/android/view/DisplayShape.java - platform/prebuilts/fullsdk/sources - Git at Google

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

 package android.view;

 import static android.view.Surface.ROTATION_0;

 import android.annotation.Nullable;
 import android.annotation.TestApi;
 import android.content.res.Resources;
 import android.content.res.TypedArray;
 import android.graphics.Matrix;
 import android.graphics.Path;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.DisplayUtils;
 import android.util.PathParser;
 import android.util.RotationUtils;

 import androidx.annotation.NonNull;

 import com.android.internal.R;
 import com.android.internal.annotations.GuardedBy;
 import com.android.internal.annotations.VisibleForTesting;

 import java.util.Objects;

 /**
  * A class representing the shape of a display. It provides a {@link Path} of the display shape of
  * the display shape.
  *
  * {@link DisplayShape} is immutable.
  */
 public final class DisplayShape implements Parcelable {

     /** @hide */
     public static final DisplayShape NONE = new DisplayShape("" /* displayShapeSpec */,
             0 /* displayWidth */, 0 /* displayHeight */, 0 /* physicalPixelDisplaySizeRatio */,
             0 /* rotation */);

     /** @hide */
     @VisibleForTesting
     public final String mDisplayShapeSpec;
     private final float mPhysicalPixelDisplaySizeRatio;
     private final int mDisplayWidth;
     private final int mDisplayHeight;
     private final int mRotation;
     private final int mOffsetX;
     private final int mOffsetY;
     private final float mScale;

     private DisplayShape(@NonNull String displayShapeSpec, int displayWidth, int displayHeight,
             float physicalPixelDisplaySizeRatio, int rotation) {
         this(displayShapeSpec, displayWidth, displayHeight, physicalPixelDisplaySizeRatio,
                 rotation, 0, 0, 1f);
     }

     private DisplayShape(@NonNull String displayShapeSpec, int displayWidth, int displayHeight,
             float physicalPixelDisplaySizeRatio, int rotation, int offsetX, int offsetY,
             float scale) {
         mDisplayShapeSpec = displayShapeSpec;
         mDisplayWidth = displayWidth;
         mDisplayHeight = displayHeight;
         mPhysicalPixelDisplaySizeRatio = physicalPixelDisplaySizeRatio;
         mRotation = rotation;
         mOffsetX = offsetX;
         mOffsetY = offsetY;
         mScale = scale;
     }

     /**
      * @hide
      */
     @NonNull
     public static DisplayShape fromResources(
             @NonNull Resources res, @NonNull String displayUniqueId, int physicalDisplayWidth,
             int physicalDisplayHeight, int displayWidth, int displayHeight) {
         final boolean isScreenRound = RoundedCorners.getBuiltInDisplayIsRound(res, displayUniqueId);
         final String spec = getSpecString(res, displayUniqueId);
         if (spec == null || spec.isEmpty()) {
             return createDefaultDisplayShape(displayWidth, displayHeight, isScreenRound);
         }
         final float physicalPixelDisplaySizeRatio = DisplayUtils.getPhysicalPixelDisplaySizeRatio(
                 physicalDisplayWidth, physicalDisplayHeight, displayWidth, displayHeight);
         return fromSpecString(spec, physicalPixelDisplaySizeRatio, displayWidth, displayHeight);
     }

     /**
      * @hide
      */
     @NonNull
     public static DisplayShape createDefaultDisplayShape(
             int displayWidth, int displayHeight, boolean isScreenRound) {
         return fromSpecString(createDefaultSpecString(displayWidth, displayHeight, isScreenRound),
                 1f, displayWidth, displayHeight);
     }

     /**
      * @hide
      */
     @TestApi
     @NonNull
     public static DisplayShape fromSpecString(@NonNull String spec,
             float physicalPixelDisplaySizeRatio, int displayWidth, int displayHeight) {
         return Cache.getDisplayShape(spec, physicalPixelDisplaySizeRatio, displayWidth,
                     displayHeight);
     }

     private static String createDefaultSpecString(int displayWidth, int displayHeight,
             boolean isCircular) {
         final String spec;
         if (isCircular) {
             final float xRadius = displayWidth / 2f;
             final float yRadius = displayHeight / 2f;
             // Draw a circular display shape.
             spec = "M0," + yRadius
                     // Draw upper half circle with arcTo command.
                     + " A" + xRadius + "," + yRadius + " 0 1,1 " + displayWidth + "," + yRadius
                     // Draw lower half circle with arcTo command.
                     + " A" + xRadius + "," + yRadius + " 0 1,1 0," + yRadius + " Z";
         } else {
             // Draw a rectangular display shape.
             spec = "M0,0"
                     // Draw top edge.
                     + " L" + displayWidth + ",0"
                     // Draw right edge.
                     + " L" + displayWidth + "," + displayHeight
                     // Draw bottom edge.
                     + " L0," + displayHeight
                     // Draw left edge by close command which draws a line from current position to
                     // the initial points (0,0).
                     + " Z";
         }
         return spec;
     }

     /**
      * Gets the display shape svg spec string of a display which is determined by the given display
      * unique id.
      *
      * Loads the default config {@link R.string#config_mainDisplayShape} if
      * {@link R.array#config_displayUniqueIdArray} is not set.
      *
      * @hide
      */
     public static String getSpecString(Resources res, String displayUniqueId) {
         final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
         final TypedArray array = res.obtainTypedArray(R.array.config_displayShapeArray);
         final String spec;
         if (index >= 0 && index < array.length()) {
             spec = array.getString(index);
         } else {
             spec = res.getString(R.string.config_mainDisplayShape);
         }
         array.recycle();
         return spec;
     }

     /**
      * @hide
      */
     public DisplayShape setRotation(int rotation) {
         return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
                 mPhysicalPixelDisplaySizeRatio, rotation, mOffsetX, mOffsetY, mScale);
     }

     /**
      * @hide
      */
     public DisplayShape setOffset(int offsetX, int offsetY) {
         return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
                 mPhysicalPixelDisplaySizeRatio, mRotation, offsetX, offsetY, mScale);
     }

     /**
      * @hide
      */
     public DisplayShape setScale(float scale) {
         return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
                 mPhysicalPixelDisplaySizeRatio, mRotation, mOffsetX, mOffsetY, scale);
     }

     @Override
     public int hashCode() {
         return Objects.hash(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
                 mPhysicalPixelDisplaySizeRatio, mRotation, mOffsetX, mOffsetY, mScale);
     }

     @Override
     public boolean equals(@Nullable Object o) {
         if (o == this) {
             return true;
         }
         if (o instanceof DisplayShape) {
             DisplayShape ds = (DisplayShape) o;
             return Objects.equals(mDisplayShapeSpec, ds.mDisplayShapeSpec)
                     && mDisplayWidth == ds.mDisplayWidth && mDisplayHeight == ds.mDisplayHeight
                     && mPhysicalPixelDisplaySizeRatio == ds.mPhysicalPixelDisplaySizeRatio
                     && mRotation == ds.mRotation && mOffsetX == ds.mOffsetX
                     && mOffsetY == ds.mOffsetY && mScale == ds.mScale;
         }
         return false;
     }

     @Override
     public String toString() {
         return "DisplayShape{"
                 + " spec=" + mDisplayShapeSpec.hashCode()
                 + " displayWidth=" + mDisplayWidth
                 + " displayHeight=" + mDisplayHeight
                 + " physicalPixelDisplaySizeRatio=" + mPhysicalPixelDisplaySizeRatio
                 + " rotation=" + mRotation
                 + " offsetX=" + mOffsetX
                 + " offsetY=" + mOffsetY
                 + " scale=" + mScale + "}";
     }

     /**
      * Returns a {@link Path} of the display shape.
      *
      * @return a {@link Path} of the display shape.
      */
     @NonNull
     public Path getPath() {
         return Cache.getPath(this);
     }

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(@NonNull Parcel dest, int flags) {
         dest.writeString8(mDisplayShapeSpec);
         dest.writeInt(mDisplayWidth);
         dest.writeInt(mDisplayHeight);
         dest.writeFloat(mPhysicalPixelDisplaySizeRatio);
         dest.writeInt(mRotation);
         dest.writeInt(mOffsetX);
         dest.writeInt(mOffsetY);
         dest.writeFloat(mScale);
     }

     public static final @NonNull Creator<DisplayShape> CREATOR = new Creator<DisplayShape>() {
         @Override
         public DisplayShape createFromParcel(Parcel in) {
             final String spec = in.readString8();
             final int displayWidth = in.readInt();
             final int displayHeight = in.readInt();
             final float ratio = in.readFloat();
             final int rotation = in.readInt();
             final int offsetX = in.readInt();
             final int offsetY = in.readInt();
             final float scale = in.readFloat();
             return new DisplayShape(spec, displayWidth, displayHeight, ratio, rotation, offsetX,
                     offsetY, scale);
         }

         @Override
         public DisplayShape[] newArray(int size) {
             return new DisplayShape[size];
         }
     };

     private static final class Cache {
         private static final Object CACHE_LOCK = new Object();

         @GuardedBy("CACHE_LOCK")
         private static String sCachedSpec;
         @GuardedBy("CACHE_LOCK")
         private static int sCachedDisplayWidth;
         @GuardedBy("CACHE_LOCK")
         private static int sCachedDisplayHeight;
         @GuardedBy("CACHE_LOCK")
         private static float sCachedPhysicalPixelDisplaySizeRatio;
         @GuardedBy("CACHE_LOCK")
         private static DisplayShape sCachedDisplayShape;

         @GuardedBy("CACHE_LOCK")
         private static DisplayShape sCacheForPath;
         @GuardedBy("CACHE_LOCK")
         private static Path sCachedPath;

         static DisplayShape getDisplayShape(String spec, float physicalPixelDisplaySizeRatio,
                 int displayWidth, int displayHeight) {
             synchronized (CACHE_LOCK) {
                 if (spec.equals(sCachedSpec)
                         && sCachedDisplayWidth == displayWidth
                         && sCachedDisplayHeight == displayHeight
                         && sCachedPhysicalPixelDisplaySizeRatio == physicalPixelDisplaySizeRatio) {
                     return sCachedDisplayShape;
                 }
             }

             final DisplayShape shape = new DisplayShape(spec, displayWidth, displayHeight,
                     physicalPixelDisplaySizeRatio, ROTATION_0);

             synchronized (CACHE_LOCK) {
                 sCachedSpec = spec;
                 sCachedDisplayWidth = displayWidth;
                 sCachedDisplayHeight = displayHeight;
                 sCachedPhysicalPixelDisplaySizeRatio = physicalPixelDisplaySizeRatio;
                 sCachedDisplayShape = shape;
             }
             return shape;
         }

         static Path getPath(@NonNull DisplayShape shape) {
             synchronized (CACHE_LOCK) {
                 if (shape.equals(sCacheForPath)) {
                     return sCachedPath;
                 }
             }

             final Path path = PathParser.createPathFromPathData(shape.mDisplayShapeSpec);

             if (!path.isEmpty()) {
                 final Matrix matrix = new Matrix();
                 if (shape.mRotation != ROTATION_0) {
                     RotationUtils.transformPhysicalToLogicalCoordinates(
                             shape.mRotation, shape.mDisplayWidth, shape.mDisplayHeight, matrix);
                 }
                 if (shape.mPhysicalPixelDisplaySizeRatio != 1f) {
                     matrix.preScale(shape.mPhysicalPixelDisplaySizeRatio,
                             shape.mPhysicalPixelDisplaySizeRatio);
                 }
                 if (shape.mOffsetX != 0 || shape.mOffsetY != 0) {
                     matrix.postTranslate(shape.mOffsetX, shape.mOffsetY);
                 }
                 if (shape.mScale != 1f) {
                     matrix.postScale(shape.mScale, shape.mScale);
                 }
                 path.transform(matrix);
             }

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

	package android.view;

	import static android.view.Surface.ROTATION_0;

	import android.annotation.Nullable;
	import android.annotation.TestApi;
	import android.content.res.Resources;
	import android.content.res.TypedArray;
	import android.graphics.Matrix;
	import android.graphics.Path;
	import android.os.Parcel;
	import android.os.Parcelable;
	import android.util.DisplayUtils;
	import android.util.PathParser;
	import android.util.RotationUtils;

	import androidx.annotation.NonNull;

	import com.android.internal.R;
	import com.android.internal.annotations.GuardedBy;
	import com.android.internal.annotations.VisibleForTesting;

	import java.util.Objects;

	/**
	* A class representing the shape of a display. It provides a {@link Path} of the display shape of
	* the display shape.
	*
	* {@link DisplayShape} is immutable.
	*/
	public final class DisplayShape implements Parcelable {

	/** @hide */
	public static final DisplayShape NONE = new DisplayShape("" /* displayShapeSpec */,
	0 /* displayWidth /, 0 / displayHeight /, 0 / physicalPixelDisplaySizeRatio */,
	0 /* rotation */);

	/** @hide */
	@VisibleForTesting
	public final String mDisplayShapeSpec;
	private final float mPhysicalPixelDisplaySizeRatio;
	private final int mDisplayWidth;
	private final int mDisplayHeight;
	private final int mRotation;
	private final int mOffsetX;
	private final int mOffsetY;
	private final float mScale;

	private DisplayShape(@NonNull String displayShapeSpec, int displayWidth, int displayHeight,
	float physicalPixelDisplaySizeRatio, int rotation) {
	this(displayShapeSpec, displayWidth, displayHeight, physicalPixelDisplaySizeRatio,
	rotation, 0, 0, 1f);
	}

	private DisplayShape(@NonNull String displayShapeSpec, int displayWidth, int displayHeight,
	float physicalPixelDisplaySizeRatio, int rotation, int offsetX, int offsetY,
	float scale) {
	mDisplayShapeSpec = displayShapeSpec;
	mDisplayWidth = displayWidth;
	mDisplayHeight = displayHeight;
	mPhysicalPixelDisplaySizeRatio = physicalPixelDisplaySizeRatio;
	mRotation = rotation;
	mOffsetX = offsetX;
	mOffsetY = offsetY;
	mScale = scale;
	}

	/**
	* @hide
	*/
	@NonNull
	public static DisplayShape fromResources(
	@NonNull Resources res, @NonNull String displayUniqueId, int physicalDisplayWidth,
	int physicalDisplayHeight, int displayWidth, int displayHeight) {
	final boolean isScreenRound = RoundedCorners.getBuiltInDisplayIsRound(res, displayUniqueId);
	final String spec = getSpecString(res, displayUniqueId);
	if (spec == null \|\| spec.isEmpty()) {
	return createDefaultDisplayShape(displayWidth, displayHeight, isScreenRound);
	}
	final float physicalPixelDisplaySizeRatio = DisplayUtils.getPhysicalPixelDisplaySizeRatio(
	physicalDisplayWidth, physicalDisplayHeight, displayWidth, displayHeight);
	return fromSpecString(spec, physicalPixelDisplaySizeRatio, displayWidth, displayHeight);
	}

	/**
	* @hide
	*/
	@NonNull
	public static DisplayShape createDefaultDisplayShape(
	int displayWidth, int displayHeight, boolean isScreenRound) {
	return fromSpecString(createDefaultSpecString(displayWidth, displayHeight, isScreenRound),
	1f, displayWidth, displayHeight);
	}

	/**
	* @hide
	*/
	@TestApi
	@NonNull
	public static DisplayShape fromSpecString(@NonNull String spec,
	float physicalPixelDisplaySizeRatio, int displayWidth, int displayHeight) {
	return Cache.getDisplayShape(spec, physicalPixelDisplaySizeRatio, displayWidth,
	displayHeight);
	}

	private static String createDefaultSpecString(int displayWidth, int displayHeight,
	boolean isCircular) {
	final String spec;
	if (isCircular) {
	final float xRadius = displayWidth / 2f;
	final float yRadius = displayHeight / 2f;
	// Draw a circular display shape.
	spec = "M0," + yRadius
	// Draw upper half circle with arcTo command.
	+ " A" + xRadius + "," + yRadius + " 0 1,1 " + displayWidth + "," + yRadius
	// Draw lower half circle with arcTo command.
	+ " A" + xRadius + "," + yRadius + " 0 1,1 0," + yRadius + " Z";
	} else {
	// Draw a rectangular display shape.
	spec = "M0,0"
	// Draw top edge.
	+ " L" + displayWidth + ",0"
	// Draw right edge.
	+ " L" + displayWidth + "," + displayHeight
	// Draw bottom edge.
	+ " L0," + displayHeight
	// Draw left edge by close command which draws a line from current position to
	// the initial points (0,0).
	+ " Z";
	}
	return spec;
	}

	/**
	* Gets the display shape svg spec string of a display which is determined by the given display
	* unique id.
	*
	* Loads the default config {@link R.string#config_mainDisplayShape} if
	* {@link R.array#config_displayUniqueIdArray} is not set.
	*
	* @hide
	*/
	public static String getSpecString(Resources res, String displayUniqueId) {
	final int index = DisplayUtils.getDisplayUniqueIdConfigIndex(res, displayUniqueId);
	final TypedArray array = res.obtainTypedArray(R.array.config_displayShapeArray);
	final String spec;
	if (index >= 0 && index < array.length()) {
	spec = array.getString(index);
	} else {
	spec = res.getString(R.string.config_mainDisplayShape);
	}
	array.recycle();
	return spec;
	}

	/**
	* @hide
	*/
	public DisplayShape setRotation(int rotation) {
	return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
	mPhysicalPixelDisplaySizeRatio, rotation, mOffsetX, mOffsetY, mScale);
	}

	/**
	* @hide
	*/
	public DisplayShape setOffset(int offsetX, int offsetY) {
	return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
	mPhysicalPixelDisplaySizeRatio, mRotation, offsetX, offsetY, mScale);
	}

	/**
	* @hide
	*/
	public DisplayShape setScale(float scale) {
	return new DisplayShape(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
	mPhysicalPixelDisplaySizeRatio, mRotation, mOffsetX, mOffsetY, scale);
	}

	@Override
	public int hashCode() {
	return Objects.hash(mDisplayShapeSpec, mDisplayWidth, mDisplayHeight,
	mPhysicalPixelDisplaySizeRatio, mRotation, mOffsetX, mOffsetY, mScale);
	}

	@Override
	public boolean equals(@Nullable Object o) {
	if (o == this) {
	return true;
	}
	if (o instanceof DisplayShape) {
	DisplayShape ds = (DisplayShape) o;
	return Objects.equals(mDisplayShapeSpec, ds.mDisplayShapeSpec)
	&& mDisplayWidth == ds.mDisplayWidth && mDisplayHeight == ds.mDisplayHeight
	&& mPhysicalPixelDisplaySizeRatio == ds.mPhysicalPixelDisplaySizeRatio
	&& mRotation == ds.mRotation && mOffsetX == ds.mOffsetX
	&& mOffsetY == ds.mOffsetY && mScale == ds.mScale;
	}
	return false;
	}

	@Override
	public String toString() {
	return "DisplayShape{"
	+ " spec=" + mDisplayShapeSpec.hashCode()
	+ " displayWidth=" + mDisplayWidth
	+ " displayHeight=" + mDisplayHeight
	+ " physicalPixelDisplaySizeRatio=" + mPhysicalPixelDisplaySizeRatio
	+ " rotation=" + mRotation
	+ " offsetX=" + mOffsetX
	+ " offsetY=" + mOffsetY
	+ " scale=" + mScale + "}";
	}

	/**
	* Returns a {@link Path} of the display shape.
	*
	* @return a {@link Path} of the display shape.
	*/
	@NonNull
	public Path getPath() {
	return Cache.getPath(this);
	}

	@Override
	public int describeContents() {
	return 0;
	}

	@Override
	public void writeToParcel(@NonNull Parcel dest, int flags) {
	dest.writeString8(mDisplayShapeSpec);
	dest.writeInt(mDisplayWidth);
	dest.writeInt(mDisplayHeight);
	dest.writeFloat(mPhysicalPixelDisplaySizeRatio);
	dest.writeInt(mRotation);
	dest.writeInt(mOffsetX);
	dest.writeInt(mOffsetY);
	dest.writeFloat(mScale);
	}

	public static final @NonNull Creator<DisplayShape> CREATOR = new Creator<DisplayShape>() {
	@Override
	public DisplayShape createFromParcel(Parcel in) {
	final String spec = in.readString8();
	final int displayWidth = in.readInt();
	final int displayHeight = in.readInt();
	final float ratio = in.readFloat();
	final int rotation = in.readInt();
	final int offsetX = in.readInt();
	final int offsetY = in.readInt();
	final float scale = in.readFloat();
	return new DisplayShape(spec, displayWidth, displayHeight, ratio, rotation, offsetX,
	offsetY, scale);
	}

	@Override
	public DisplayShape[] newArray(int size) {
	return new DisplayShape[size];
	}
	};

	private static final class Cache {
	private static final Object CACHE_LOCK = new Object();

	@GuardedBy("CACHE_LOCK")
	private static String sCachedSpec;
	@GuardedBy("CACHE_LOCK")
	private static int sCachedDisplayWidth;
	@GuardedBy("CACHE_LOCK")
	private static int sCachedDisplayHeight;
	@GuardedBy("CACHE_LOCK")
	private static float sCachedPhysicalPixelDisplaySizeRatio;
	@GuardedBy("CACHE_LOCK")
	private static DisplayShape sCachedDisplayShape;

	@GuardedBy("CACHE_LOCK")
	private static DisplayShape sCacheForPath;
	@GuardedBy("CACHE_LOCK")
	private static Path sCachedPath;

	static DisplayShape getDisplayShape(String spec, float physicalPixelDisplaySizeRatio,
	int displayWidth, int displayHeight) {
	synchronized (CACHE_LOCK) {
	if (spec.equals(sCachedSpec)
	&& sCachedDisplayWidth == displayWidth
	&& sCachedDisplayHeight == displayHeight
	&& sCachedPhysicalPixelDisplaySizeRatio == physicalPixelDisplaySizeRatio) {
	return sCachedDisplayShape;
	}
	}

	final DisplayShape shape = new DisplayShape(spec, displayWidth, displayHeight,
	physicalPixelDisplaySizeRatio, ROTATION_0);

	synchronized (CACHE_LOCK) {
	sCachedSpec = spec;
	sCachedDisplayWidth = displayWidth;
	sCachedDisplayHeight = displayHeight;
	sCachedPhysicalPixelDisplaySizeRatio = physicalPixelDisplaySizeRatio;
	sCachedDisplayShape = shape;
	}
	return shape;
	}

	static Path getPath(@NonNull DisplayShape shape) {
	synchronized (CACHE_LOCK) {
	if (shape.equals(sCacheForPath)) {
	return sCachedPath;
	}
	}

	final Path path = PathParser.createPathFromPathData(shape.mDisplayShapeSpec);

	if (!path.isEmpty()) {
	final Matrix matrix = new Matrix();
	if (shape.mRotation != ROTATION_0) {
	RotationUtils.transformPhysicalToLogicalCoordinates(
	shape.mRotation, shape.mDisplayWidth, shape.mDisplayHeight, matrix);
	}
	if (shape.mPhysicalPixelDisplaySizeRatio != 1f) {
	matrix.preScale(shape.mPhysicalPixelDisplaySizeRatio,
	shape.mPhysicalPixelDisplaySizeRatio);
	}
	if (shape.mOffsetX != 0 \|\| shape.mOffsetY != 0) {
	matrix.postTranslate(shape.mOffsetX, shape.mOffsetY);
	}
	if (shape.mScale != 1f) {
	matrix.postScale(shape.mScale, shape.mScale);
	}
	path.transform(matrix);
	}

	synchronized (CACHE_LOCK) {
	sCacheForPath = shape;
	sCachedPath = path;
	}
	return path;
	}
	}
	}