TEST_F(SurfaceTest, ConcreteTypeIsSurface) { sp<ANativeWindow> anw(mSurface); int result = -123; int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result); EXPECT_EQ(NO_ERROR, err); EXPECT_EQ(NATIVE_WINDOW_SURFACE, result); }
TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) { sp<ANativeWindow> anw(mSurface); int result = -123; int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &result); EXPECT_EQ(NO_ERROR, err); EXPECT_EQ(1, result); }
SfSurface* sf_surface_create(SfClient* client, SfSurfaceCreationParameters* params) { assert(client); assert(params); SfSurface* surface = new SfSurface(); surface->client = client; surface->surface_control = surface->client->client->createSurface( android::String8(params->name), params->w, params->h, android::PIXEL_FORMAT_RGBA_8888, 0x300); if (surface->surface_control == NULL) { report_surface_control_is_null_during_creation(); delete(surface); return NULL; } surface->surface = surface->surface_control->getSurface(); if (surface->surface == NULL) { report_surface_is_null_during_creation(); delete(surface); return NULL; } sf_client_begin_transaction(client); { surface->surface_control->setPosition(params->x, params->y); surface->surface_control->setLayer(params->layer); surface->surface_control->setAlpha(params->alpha); } sf_client_end_transaction(client); if (params->create_egl_window_surface) { if (client->egl_support) { android::sp<ANativeWindow> anw(surface->surface); surface->egl_surface = eglCreateWindowSurface( surface->client->egl_display, surface->client->egl_config, anw.get(), NULL); } else fprintf(stderr, "Warning: params->create_egl_window_surface not " "supported, EGL support disabled\n"); } return surface; }
TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) { mSurfaceControl.clear(); sp<ANativeWindow> anw(mSurface); int result = -123; int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &result); EXPECT_EQ(NO_ERROR, err); EXPECT_EQ(1, result); }
status_t BufferProducerThread::readyToRun() { sp<ANativeWindow> anw(mSurface); status_t err = native_window_set_usage(anw.get(), mStream.buffer_producer.usage); if (err != NO_ERROR) { return err; } err = native_window_set_buffers_dimensions( anw.get(), mStream.buffer_producer.width, mStream.buffer_producer.height); if (err != NO_ERROR) { return err; } err = native_window_set_buffers_format(anw.get(), mStream.buffer_producer.format); if (err != NO_ERROR) { return err; } return NO_ERROR; }
bool BufferProducerThread::threadLoop() { Mutex::Autolock autoLock(&mLock); status_t err = NO_ERROR; if (mSurface == NULL) { err = mCondition.waitRelative(mLock, s2ns(1)); // It's OK to time out here. if (err != NO_ERROR && err != TIMED_OUT) { ALOGE("error %d while wating for non-null surface to be set", err); return false; } return true; } sp<ANativeWindow> anw(mSurface); while (mBufferState == CAPTURING) { err = mCondition.waitRelative(mLock, s2ns(1)); if (err != NO_ERROR) { ALOGE("error %d while wating for buffer state to change.", err); return false; } } if (mBufferState == CAPTURED && anw != NULL) { err = anw->queueBuffer(anw.get(), mBuffer.get(), -1); if (err != NO_ERROR) { ALOGE("error %d while queueing buffer to surface", err); return false; } mBuffer.clear(); mBufferState = RELEASED; } if (mBuffer == NULL && !mShutdown && anw != NULL) { ANativeWindowBuffer_t* buffer = NULL; err = native_window_dequeue_buffer_and_wait(anw.get(), &buffer); if (err != NO_ERROR) { ALOGE("error %d while dequeueing buffer to surface", err); return false; } mBuffer = buffer; mBufferState = CAPTURING; mDevice->request_capture(mDevice, mDeviceId, mStream.stream_id, buffer->handle, ++mSeq); } return true; }
// This test probably doesn't belong here. TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) { sp<ANativeWindow> anw(mSurface); // Verify the screenshot works with no protected buffers. sp<CpuConsumer> consumer = new CpuConsumer(1); sp<ISurfaceComposer> sf(ComposerService::getComposerService()); sp<IBinder> display(sf->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); ASSERT_EQ(NO_ERROR, sf->captureScreen(display, consumer->getBufferQueue(), 64, 64, 0, 0x7fffffff, true)); // Set the PROTECTED usage bit and verify that the screenshot fails. Note // that we need to dequeue a buffer in order for it to actually get // allocated in SurfaceFlinger. ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), GRALLOC_USAGE_PROTECTED)); ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3)); ANativeWindowBuffer* buf = 0; status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf); if (err) { // we could fail if GRALLOC_USAGE_PROTECTED is not supported. // that's okay as long as this is the reason for the failure. // try again without the GRALLOC_USAGE_PROTECTED bit. ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0)); ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), &buf)); return; } ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1)); for (int i = 0; i < 4; i++) { // Loop to make sure SurfaceFlinger has retired a protected buffer. ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), &buf)); ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1)); } ASSERT_EQ(NO_ERROR, sf->captureScreen(display, consumer->getBufferQueue(), 64, 64, 0, 0x7fffffff, true)); }