Java

C++

SurfaceSession.java

SurfaceComposeClient

對應JNI檔案為：

android_view_surfacesession.cpp

SurfaceControl.java

SurfaceControl + Composer

對應JNI檔案為：

android_view_surfacecontrol.cpp

Surface.java

Surface

對應JNI檔案為：

Android_view_surface.cpp

  /** Create a new connection with the surface flinger. */

    public SurfaceSession() {

        mNativeClient = nativeCreate();

    }

// android_view_surfacesession.cpp

static jlong nativeCreate(JNIEnv* env, jclass clazz) {

    SurfaceComposerClient* client = new SurfaceComposerClient();

    client->incStrong((void*)nativeCreate);

    return reinterpret_cast<jlong>(client);

}

    public SurfaceControl(SurfaceSession session,

            String name, int w, int h, int format, int flags)

                    throws OutOfResourcesException {

        if (session == null) {

            throw new IllegalArgumentException("session must not be null");

        }

        if (name == null) {

            throw new IllegalArgumentException("name must not be null");

        }

        mName = name;

        mNativeObject = nativeCreate(session, name, w, h, format, flags);

        if (mNativeObject == 0) {

            throw new OutOfResourcesException(

                    "Couldn't allocate SurfaceControl native object");

        }

        mCloseGuard.open("release");

    }

//android_view_surfacecontrol.cpp

static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj,

        jstring nameStr, jint w, jint h, jint format, jint flags) {

    ScopedUtfChars name(env, nameStr);

    sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));

   sp<SurfaceControl> surface = client->createSurface(

String8(name.c_str()), w, h, format, flags);

    if (surface == NULL) {

        jniThrowException(env, OutOfResourcesException, NULL);

        return 0;

    }

    surface->incStrong((void *)nativeCreate);

    return reinterpret_cast<jlong>(surface.get());

}

    public void copyFrom(SurfaceControl other) {

        if (other == null) {

            throw new IllegalArgumentException("other must not be null");

        }

        long surfaceControlPtr = other.mNativeObject;

        if (surfaceControlPtr == 0) {

            throw new NullPointerException(

                    "SurfaceControl native object is null. Are you using a released SurfaceControl?");

        }

        long newNativeObject = nativeCreateFromSurfaceControl(surfaceControlPtr);

        synchronized (mLock) {

            if (mNativeObject != 0) {

                nativeRelease(mNativeObject);

            }

            setNativeObjectLocked(newNativeObject);

        }

    }

static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,

        jlong surfaceControlNativeObj) {

    /*

     * This is used by the WindowManagerService just after constructing

     * a Surface and is necessary for returning the Surface reference to

     * the caller. At this point, we should only have a SurfaceControl.

     */

    sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));

    sp<Surface> surface(ctrl->getSurface());

    if (surface != NULL) {

        surface->incStrong(&sRefBaseOwner);

    }

    return reinterpret_cast<jlong>(surface.get());

}

public Canvas lockCanvas(Rect inOutDirty)

            throws Surface.OutOfResourcesException, IllegalArgumentException {

        synchronized (mLock) {

            checkNotReleasedLocked();

            if (mLockedObject != 0) {

                // Ideally, nativeLockCanvas() would throw in this situation and prevent the

                // double-lock, but that won't happen if mNativeObject was updated.  We can't

                // abandon the old mLockedObject because it might still be in use, so instead

                // we just refuse to re-lock the Surface.

                throw new IllegalArgumentException("Surface was already locked");

            }

            mLockedObject = nativeLockCanvas(mNativeObject, mCanvas, inOutDirty);

            return mCanvas;

        }

}

//android_view_surface.cpp

static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,

        jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {

    sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

    if (!isSurfaceValid(surface)) {

        doThrowIAE(env);

        return 0;

    }

    Rect dirtyRect;

    Rect* dirtyRectPtr = NULL;

    if (dirtyRectObj) {

        dirtyRect.left   = env->GetIntField(dirtyRectObj, gRectClassInfo.left);

        dirtyRect.top    = env->GetIntField(dirtyRectObj, gRectClassInfo.top);

        dirtyRect.right  = env->GetIntField(dirtyRectObj, gRectClassInfo.right);

        dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);

        dirtyRectPtr = &dirtyRect;

    }

    ANativeWindow_Buffer outBuffer;

    status_t err = surface->lock(&outBuffer, dirtyRectPtr);

    if (err < 0) {

        const char* const exception = (err == NO_MEMORY) ?

                OutOfResourcesException :

                "java/lang/IllegalArgumentException";

        jniThrowException(env, exception, NULL);

        return 0;

    }

    // Associate a SkCanvas object to this surface

    env->SetIntField(canvasObj, gCanvasClassInfo.mSurfaceFormat, outBuffer.format);

    SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height,

convertPixelFormat(outBuffer.format),

kPremul_SkAlphaType);

    if (outBuffer.format == PIXEL_FORMAT_RGBX_8888) {

        info.fAlphaType = kOpaque_SkAlphaType;

    }

    SkBitmap bitmap;

    ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);

    bitmap.setInfo(info, bpr);

    if (outBuffer.width > 0 && outBuffer.height > 0) {

        bitmap.setPixels(outBuffer.bits);

    } else {

        // be safe with an empty bitmap.

        bitmap.setPixels(NULL);

    }

    env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap,

reinterpret_cast<jlong>(&bitmap));

    if (dirtyRectPtr) {

        SkCanvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);

        nativeCanvas->clipRect( SkRect::Make(reinterpret_cast<const SkIRect&>(dirtyRect)) );

    }

    if (dirtyRectObj) {

        env->SetIntField(dirtyRectObj, gRectClassInfo.left,   dirtyRect.left);

        env->SetIntField(dirtyRectObj, gRectClassInfo.top,    dirtyRect.top);

        env->SetIntField(dirtyRectObj, gRectClassInfo.right,  dirtyRect.right);

        env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);

    }

    // Create another reference to the surface and return it.  This reference

    // should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,

    // because the latter could be replaced while the surface is locked.

    sp<Surface> lockedSurface(surface);

    lockedSurface->incStrong(&sRefBaseOwner);

    return (jlong) lockedSurface.get();

}

status_t Surface::lock(

        ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)

{

    if (mLockedBuffer != 0) {

        ALOGE("Surface::lock failed, already locked");

        return INVALID_OPERATION;

    }

    if (!mConnectedToCpu) {

        int err = Surface::connect(NATIVE_WINDOW_API_CPU);

        if (err) {

            return err;

        }

        // we're intending to do software rendering from this point

        setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);

    }

    ANativeWindowBuffer* out;

    int fenceFd = -1;

    status_t err = dequeueBuffer(&out, &fenceFd);

    ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));

    if (err == NO_ERROR) {

        sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));

        const Rect bounds(backBuffer->width, backBuffer->height);

        Region newDirtyRegion;

        if (inOutDirtyBounds) {

            newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));

            newDirtyRegion.andSelf(bounds);

        } else {

            newDirtyRegion.set(bounds);

        }

        // figure out if we can copy the frontbuffer back

        const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);

        const bool canCopyBack = (frontBuffer != 0 &&

                backBuffer->width  == frontBuffer->width &&

                backBuffer->height == frontBuffer->height &&

                backBuffer->format == frontBuffer->format);

        if (canCopyBack) {

            // copy the area that is invalid and not repainted this round

            const Region copyback(mDirtyRegion.subtract(newDirtyRegion));

            if (!copyback.isEmpty())

                copyBlt(backBuffer, frontBuffer, copyback);

        } else {

            // if we can't copy-back anything, modify the user's dirty

            // region to make sure they redraw the whole buffer

            newDirtyRegion.set(bounds);

            mDirtyRegion.clear();

            Mutex::Autolock lock(mMutex);

            for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) {

                mSlots[i].dirtyRegion.clear();

            }

        }

        { // scope for the lock

            Mutex::Autolock lock(mMutex);

            int backBufferSlot(getSlotFromBufferLocked(backBuffer.get()));

            if (backBufferSlot >= 0) {

                Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion);

                mDirtyRegion.subtract(dirtyRegion);

                dirtyRegion = newDirtyRegion;

            }

        }

        mDirtyRegion.orSelf(newDirtyRegion);

        if (inOutDirtyBounds) {

            *inOutDirtyBounds = newDirtyRegion.getBounds();

        }

        void* vaddr;

        status_t res = backBuffer->lockAsync(

                GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,

                newDirtyRegion.bounds(), &vaddr, fenceFd);

        ALOGW_IF(res, "failed locking buffer (handle = %p)",

                backBuffer->handle);

        if (res != 0) {

            err = INVALID_OPERATION;

        } else {

            mLockedBuffer = backBuffer;

            outBuffer->width  = backBuffer->width;

            outBuffer->height = backBuffer->height;

            outBuffer->stride = backBuffer->stride;

            outBuffer->format = backBuffer->format;

            outBuffer->bits   = vaddr;

        }

    }

    return err;

}

static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,

        jlong nativeObject, jobject canvasObj) {

    sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

    if (!isSurfaceValid(surface)) {

        return;

    }

    // detach the canvas from the surface

    env->CallVoidMethod(canvasObj, gCanvasClassInfo.setNativeBitmap, (jlong)0);

    // unlock surface

    status_t err = surface->unlockAndPost();

    if (err < 0) {

        doThrowIAE(env);

    }

}

status_t Surface::unlockAndPost()

{

    if (mLockedBuffer == 0) {

        ALOGE("Surface::unlockAndPost failed, no locked buffer");

        return INVALID_OPERATION;

    }

    int fd = -1;

    status_t err = mLockedBuffer->unlockAsync(&fd);

    ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);

    err = queueBuffer(mLockedBuffer.get(), fd);

    ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",

            mLockedBuffer->handle, strerror(-err));

    mPostedBuffer = mLockedBuffer;

    mLockedBuffer = 0;

    return err;

}