C++ sp::connect方法代码示例

JNIEXPORT int JNICALL Java_com_mediatek_ut_SurfaceFlingerTest_connect(JNIEnv *_env, jobject /*_this*/,
    jobject native_window, jboolean useDefaultSize, jint w, jint h, jboolean updateScreen, jint api, jint format, jint colorIndex) {
    if (utProc == NULL)
        utProc = new SfUtProc();

    sp<ANativeWindow> window;
    utProc->mId++;
    LOGD("connect, native_window=%p, useDefaultSize=%d, w=%d, h=%d, updateScreen=%d, api=%d, format=%x, colorIndex=%d",
        native_window, useDefaultSize, w, h, updateScreen, api, format, colorIndex);

    if (native_window == NULL) {
        LOGW("native_window is null");
//not_valid_surface:
//        jniThrowException(_env, "java/lang/IllegalArgumentException",
//                "[SFT_jni] Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");
        return -1;
    }

//    window = android_view_Surface_getNativeWindow(_env, native_window);
    window = ANativeWindow_fromSurface(_env, native_window);
    if (window == NULL) {
        LOGW("getNative window is null");
//        goto not_valid_surface;
        return -1;
    }

    utProc->connect(utProc->mId, window, useDefaultSize, w, h, updateScreen, api, format, colorIndex);

    return utProc->mId;
}

// construct a camera client from an existing camera remote
sp<Camera> Camera::create(const sp<ICamera>& camera)
{
     LOGV("create");
     if (camera == 0) {
         LOGE("camera remote is a NULL pointer");
         return 0;
     }

    sp<Camera> c = new Camera();
    if (camera->connect(c) == NO_ERROR) {
        c->mStatus = NO_ERROR;
        c->mCamera = camera;
        camera->asBinder()->linkToDeath(c);
    }
    return c;
}

 AfterConnect() {
     cs = getCameraService();
     cc = new MCameraClient();
     c = cs->connect(cc);
     ASSERT(c != 0);
 }

status_t Camera3StreamSplitter::addOutputLocked(const sp<Surface>& outputQueue) {
    ATRACE_CALL();
    if (outputQueue == nullptr) {
        SP_LOGE("addOutput: outputQueue must not be NULL");
        return BAD_VALUE;
    }

    sp<IGraphicBufferProducer> gbp = outputQueue->getIGraphicBufferProducer();
    // Connect to the buffer producer
    sp<OutputListener> listener(new OutputListener(this, gbp));
    IInterface::asBinder(gbp)->linkToDeath(listener);
    status_t res = outputQueue->connect(NATIVE_WINDOW_API_CAMERA, listener);
    if (res != NO_ERROR) {
        SP_LOGE("addOutput: failed to connect (%d)", res);
        return res;
    }

    // Query consumer side buffer count, and update overall buffer count
    int maxConsumerBuffers = 0;
    res = static_cast<ANativeWindow*>(outputQueue.get())->query(
            outputQueue.get(),
            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &maxConsumerBuffers);
    if (res != OK) {
        SP_LOGE("%s: Unable to query consumer undequeued buffer count"
              " for surface", __FUNCTION__);
        return res;
    }

    SP_LOGV("%s: Consumer wants %d buffers, Producer wants %zu", __FUNCTION__,
            maxConsumerBuffers, mMaxHalBuffers);
    size_t totalBufferCount = maxConsumerBuffers + mMaxHalBuffers;
    res = native_window_set_buffer_count(outputQueue.get(),
            totalBufferCount);
    if (res != OK) {
        SP_LOGE("%s: Unable to set buffer count for surface %p",
                __FUNCTION__, outputQueue.get());
        return res;
    }

    // Set dequeueBuffer/attachBuffer timeout if the consumer is not hw composer or hw texture.
    // We need skip these cases as timeout will disable the non-blocking (async) mode.
    uint64_t usage = 0;
    res = native_window_get_consumer_usage(static_cast<ANativeWindow*>(outputQueue.get()), &usage);
    if (!(usage & (GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_TEXTURE))) {
        outputQueue->setDequeueTimeout(kDequeueBufferTimeout);
    }

    res = gbp->allowAllocation(false);
    if (res != OK) {
        SP_LOGE("%s: Failed to turn off allocation for outputQueue", __FUNCTION__);
        return res;
    }

    // Add new entry into mOutputs
    mOutputs.push_back(gbp);
    mNotifiers[gbp] = listener;
    mOutputSlots[gbp] = std::make_unique<OutputSlots>(totalBufferCount);

    mMaxConsumerBuffers += maxConsumerBuffers;
    return NO_ERROR;
}