339 lines
11 KiB
Java
339 lines
11 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|