| /* |
| * 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.app.wallpapereffectsgeneration; |
| |
| import android.annotation.IntDef; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.annotation.SystemApi; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Objects; |
| |
| /** |
| * A {@link CinematicEffectResponse} include textured meshes |
| * and camera attributes of key frames. |
| * |
| * @hide |
| */ |
| @SystemApi |
| public final class CinematicEffectResponse implements Parcelable { |
| /** @hide */ |
| @IntDef(prefix = {"CINEMATIC_EFFECT_STATUS_"}, |
| value = {CINEMATIC_EFFECT_STATUS_ERROR, |
| CINEMATIC_EFFECT_STATUS_OK, |
| CINEMATIC_EFFECT_STATUS_NOT_READY, |
| CINEMATIC_EFFECT_STATUS_PENDING, |
| CINEMATIC_EFFECT_STATUS_TOO_MANY_REQUESTS, |
| CINEMATIC_EFFECT_STATUS_FEATURE_DISABLED, |
| CINEMATIC_EFFECT_STATUS_IMAGE_FORMAT_NOT_SUITABLE, |
| CINEMATIC_EFFECT_STATUS_CONTENT_UNSUPPORTED, |
| CINEMATIC_EFFECT_STATUS_CONTENT_TARGET_ERROR, |
| CINEMATIC_EFFECT_STATUS_CONTENT_TOO_FLAT, |
| CINEMATIC_EFFECT_STATUS_ANIMATION_FAILURE |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface CinematicEffectStatusCode {} |
| |
| /** Cinematic effect generation failure with generic error. */ |
| public static final int CINEMATIC_EFFECT_STATUS_ERROR = 0; |
| |
| /** Cinematic effect generation success. */ |
| public static final int CINEMATIC_EFFECT_STATUS_OK = 1; |
| |
| /** |
| * Service not ready for cinematic effect generation, e.g. a |
| * dependency is unavailable. |
| */ |
| public static final int CINEMATIC_EFFECT_STATUS_NOT_READY = 2; |
| |
| /** |
| * There is already a task being processed for the same task id. |
| * Client should wait for the response and not send the same request |
| * again. |
| */ |
| public static final int CINEMATIC_EFFECT_STATUS_PENDING = 3; |
| |
| /** Too many requests (with different task id) for server to handle. */ |
| public static final int CINEMATIC_EFFECT_STATUS_TOO_MANY_REQUESTS = 4; |
| |
| /** Feature is disabled, for example, in an emergency situation. */ |
| public static final int CINEMATIC_EFFECT_STATUS_FEATURE_DISABLED = 5; |
| |
| /** Image format related problems (i.e. resolution or aspect ratio problems). */ |
| public static final int CINEMATIC_EFFECT_STATUS_IMAGE_FORMAT_NOT_SUITABLE = 6; |
| |
| /** |
| * The cinematic effect feature is not supported on certain types of images, |
| * for example, some implementation only support portrait. |
| */ |
| public static final int CINEMATIC_EFFECT_STATUS_CONTENT_UNSUPPORTED = 7; |
| |
| /** |
| * Cannot generate cinematic effect with the targets on the image, for example, |
| * too many targets on the image. |
| */ |
| public static final int CINEMATIC_EFFECT_STATUS_CONTENT_TARGET_ERROR = 8; |
| |
| /** Image is too flat to generate cinematic effect. */ |
| public static final int CINEMATIC_EFFECT_STATUS_CONTENT_TOO_FLAT = 9; |
| |
| /** Something is wrong with generating animation. */ |
| public static final int CINEMATIC_EFFECT_STATUS_ANIMATION_FAILURE = 10; |
| |
| /** @hide */ |
| @IntDef(prefix = {"IMAGE_CONTENT_TYPE_"}, |
| value = {IMAGE_CONTENT_TYPE_UNKNOWN, |
| IMAGE_CONTENT_TYPE_PEOPLE_PORTRAIT, |
| IMAGE_CONTENT_TYPE_LANDSCAPE, |
| IMAGE_CONTENT_TYPE_OTHER |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface ImageContentType {} |
| |
| /** Unable to determine image type. */ |
| public static final int IMAGE_CONTENT_TYPE_UNKNOWN = 0; |
| /** Image content is people portrait. */ |
| public static final int IMAGE_CONTENT_TYPE_PEOPLE_PORTRAIT = 1; |
| /** Image content is landscape. */ |
| public static final int IMAGE_CONTENT_TYPE_LANDSCAPE = 2; |
| /** Image content is not people portrait or landscape. */ |
| public static final int IMAGE_CONTENT_TYPE_OTHER = 3; |
| |
| |
| @CinematicEffectStatusCode |
| private int mStatusCode; |
| |
| /** The id of the cinematic effect generation task. */ |
| @NonNull |
| private String mTaskId; |
| |
| @ImageContentType |
| private int mImageContentType; |
| |
| /** The textured mesh required to render cinematic effect. */ |
| @NonNull |
| private List<TexturedMesh> mTexturedMeshes; |
| |
| /** The start camera position for animation. */ |
| @Nullable |
| private CameraAttributes mStartKeyFrame; |
| |
| /** The end camera position for animation. */ |
| @Nullable |
| private CameraAttributes mEndKeyFrame; |
| |
| private CinematicEffectResponse(Parcel in) { |
| mStatusCode = in.readInt(); |
| mTaskId = in.readString(); |
| mImageContentType = in.readInt(); |
| mTexturedMeshes = new ArrayList<TexturedMesh>(); |
| in.readTypedList(mTexturedMeshes, TexturedMesh.CREATOR); |
| mStartKeyFrame = in.readTypedObject(CameraAttributes.CREATOR); |
| mEndKeyFrame = in.readTypedObject(CameraAttributes.CREATOR); |
| } |
| |
| private CinematicEffectResponse(@CinematicEffectStatusCode int statusCode, |
| String taskId, |
| @ImageContentType int imageContentType, |
| List<TexturedMesh> texturedMeshes, |
| CameraAttributes startKeyFrame, |
| CameraAttributes endKeyFrame) { |
| mStatusCode = statusCode; |
| mTaskId = taskId; |
| mImageContentType = imageContentType; |
| mStartKeyFrame = startKeyFrame; |
| mEndKeyFrame = endKeyFrame; |
| mTexturedMeshes = texturedMeshes; |
| } |
| |
| /** Gets the cinematic effect generation status code. */ |
| @CinematicEffectStatusCode |
| public int getStatusCode() { |
| return mStatusCode; |
| } |
| |
| /** Get the task id. */ |
| @NonNull |
| public String getTaskId() { |
| return mTaskId; |
| } |
| |
| /** |
| * Get the image content type, which briefly classifies what's |
| * the content of image, like people portrait, landscape etc. |
| */ |
| @ImageContentType |
| public int getImageContentType() { |
| return mImageContentType; |
| } |
| |
| /** Get the textured meshes. */ |
| @NonNull |
| public List<TexturedMesh> getTexturedMeshes() { |
| return mTexturedMeshes; |
| } |
| |
| /** |
| * Get the camera attributes (position info and other parameters, see docs of |
| * {@link CameraAttributes}) of the start key frame on the animation path. |
| */ |
| @Nullable |
| public CameraAttributes getStartKeyFrame() { |
| return mStartKeyFrame; |
| } |
| |
| /** |
| * Get the camera attributes (position info and other parameters, see docs of |
| * {@link CameraAttributes}) of the end key frame on the animation path. |
| */ |
| @Nullable |
| public CameraAttributes getEndKeyFrame() { |
| return mEndKeyFrame; |
| } |
| |
| @NonNull |
| public static final Creator<CinematicEffectResponse> CREATOR = |
| new Creator<CinematicEffectResponse>() { |
| @Override |
| public CinematicEffectResponse createFromParcel(Parcel in) { |
| return new CinematicEffectResponse(in); |
| } |
| |
| @Override |
| public CinematicEffectResponse[] newArray(int size) { |
| return new CinematicEffectResponse[size]; |
| } |
| }; |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(@NonNull Parcel out, int flags) { |
| out.writeInt(mStatusCode); |
| out.writeString(mTaskId); |
| out.writeInt(mImageContentType); |
| out.writeTypedList(mTexturedMeshes, flags); |
| out.writeTypedObject(mStartKeyFrame, flags); |
| out.writeTypedObject(mEndKeyFrame, flags); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (o == null || getClass() != o.getClass()) { |
| return false; |
| } |
| CinematicEffectResponse that = (CinematicEffectResponse) o; |
| return mTaskId.equals(that.mTaskId); |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(mTaskId); |
| } |
| /** |
| * Builder of {@link CinematicEffectResponse} |
| * |
| * @hide |
| */ |
| @SystemApi |
| public static final class Builder { |
| @CinematicEffectStatusCode |
| private int mStatusCode; |
| @NonNull |
| private String mTaskId; |
| @ImageContentType |
| private int mImageContentType; |
| @NonNull |
| private List<TexturedMesh> mTexturedMeshes; |
| @Nullable |
| private CameraAttributes mStartKeyFrame; |
| @Nullable |
| private CameraAttributes mEndKeyFrame; |
| |
| /** |
| * Constructor with task id and status code. |
| * |
| * @hide |
| */ |
| @SystemApi |
| public Builder(@CinematicEffectStatusCode int statusCode, @NonNull String taskId) { |
| mStatusCode = statusCode; |
| mTaskId = taskId; |
| } |
| |
| /** |
| * Sets the image content type. |
| */ |
| @NonNull |
| public Builder setImageContentType(@ImageContentType int imageContentType) { |
| mImageContentType = imageContentType; |
| return this; |
| } |
| |
| |
| /** |
| * Sets the textured meshes. |
| */ |
| @NonNull |
| public Builder setTexturedMeshes(@NonNull List<TexturedMesh> texturedMeshes) { |
| mTexturedMeshes = texturedMeshes; |
| return this; |
| } |
| |
| /** |
| * Sets start key frame. |
| */ |
| @NonNull |
| public Builder setStartKeyFrame(@Nullable CameraAttributes startKeyFrame) { |
| mStartKeyFrame = startKeyFrame; |
| return this; |
| } |
| |
| /** |
| * Sets end key frame. |
| */ |
| @NonNull |
| public Builder setEndKeyFrame(@Nullable CameraAttributes endKeyFrame) { |
| mEndKeyFrame = endKeyFrame; |
| return this; |
| } |
| |
| /** |
| * Builds a {@link CinematicEffectResponse} instance. |
| */ |
| @NonNull |
| public CinematicEffectResponse build() { |
| if (mTexturedMeshes == null) { |
| // Place holder because build doesn't allow list to be nullable. |
| mTexturedMeshes = new ArrayList<>(0); |
| } |
| return new CinematicEffectResponse(mStatusCode, mTaskId, mImageContentType, |
| mTexturedMeshes, mStartKeyFrame, mEndKeyFrame); |
| } |
| } |
| } |