public class Surface implements Parcelable {...}

final Object mLock = new Object(); // protects the native state

private String mName;

long mNativeObject; // package scope only for SurfaceControl access

private long mLockedObject;
private int mGenerationId; // incremented each time mNativeObject changes
private final Canvas mCanvas = new CompatibleCanvas();

// A matrix to scale the matrix set by application. This is set to null for
// non compatibility mode.
private Matrix mCompatibleMatrix;

private HwuiContext mHwuiContext;

private boolean mIsSingleBuffered;
private boolean mIsSharedBufferModeEnabled;
private boolean mIsAutoRefreshEnabled;

/**
 * Create an empty surface, which will later be filled in by readFromParcel().
 * @hide
 */
@UnsupportedAppUsage
public Surface() {
}

/**
 * Create a Surface associated with a given {@link SurfaceControl}. Buffers submitted to this
 * surface will be displayed by the system compositor according to the parameters
 * specified by the control. Multiple surfaces may be constructed from one SurfaceControl,
 * but only one can be connected (e.g. have an active EGL context) at a time.
 *
 * @param from The SurfaceControl to associate this Surface with
 */
public Surface(@NonNull SurfaceControl from) {
    copyFrom(from);
}

/**
 * Create Surface from a {@link SurfaceTexture}.
 *
 * Images drawn to the Surface will be made available to the {@link
 * SurfaceTexture}, which can attach them to an OpenGL ES texture via {@link
 * SurfaceTexture#updateTexImage}.
 *
 * Please note that holding onto the Surface created here is not enough to
 * keep the provided SurfaceTexture from being reclaimed.  In that sense,
 * the Surface will act like a
 * {@link java.lang.ref.WeakReference weak reference} to the SurfaceTexture.
 *
 * @param surfaceTexture The {@link SurfaceTexture} that is updated by this
 * Surface.
 * @throws OutOfResourcesException if the surface could not be created.
 */
public Surface(SurfaceTexture surfaceTexture) {
    if (surfaceTexture == null) {
        throw new IllegalArgumentException("surfaceTexture must not be null");
    }
    mIsSingleBuffered = surfaceTexture.isSingleBuffered();
    synchronized (mLock) {
        mName = surfaceTexture.toString();
        setNativeObjectLocked(nativeCreateFromSurfaceTexture(surfaceTexture));
    }
}

/* called from android_view_Surface_createFromIGraphicBufferProducer() */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private Surface(long nativeObject) {
    synchronized (mLock) {
        setNativeObjectLocked(nativeObject);
    }
}

/**
 * An instance of this class represents a connection to the surface
 * flinger, from which you can create one or more Surface instances that will
 * be composited to the screen.
 * {@hide}
 */
public final class SurfaceSession {
    // Note: This field is accessed by native code.
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    private long mNativeClient; // SurfaceComposerClient*

    private static native long nativeCreate();
    private static native void nativeDestroy(long ptr);

    /** Create a new connection with the surface flinger. */
    @UnsupportedAppUsage
    public SurfaceSession() {
        mNativeClient = nativeCreate();
    }

    /* no user serviceable parts here ... */
    @Override
    protected void finalize() throws Throwable {
        try {
            kill();
        } finally {
            super.finalize();
        }
    }

    /**
     * Remove the reference to the native Session object. The native object may still exist if
     * there are other references to it, but it cannot be accessed from this Java object anymore.
     */
    @UnsupportedAppUsage
    public void kill() {
        if (mNativeClient != 0) {
            nativeDestroy(mNativeClient);
            mNativeClient = 0;
        }
    }
}