1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "DummyConsumer.h"
18
19#include <gtest/gtest.h>
20
21#include <binder/IMemory.h>
22#include <gui/ISurfaceComposer.h>
23#include <gui/Surface.h>
24#include <gui/SurfaceComposerClient.h>
25#include <gui/BufferItemConsumer.h>
26#include <ui/Rect.h>
27#include <utils/String8.h>
28
29#include <private/gui/ComposerService.h>
30#include <binder/ProcessState.h>
31
32namespace android {
33
34class SurfaceTest : public ::testing::Test {
35protected:
36
37    SurfaceTest() {
38        ProcessState::self()->startThreadPool();
39    }
40
41    virtual void SetUp() {
42        mComposerClient = new SurfaceComposerClient;
43        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
44
45        mSurfaceControl = mComposerClient->createSurface(
46                String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
47
48        ASSERT_TRUE(mSurfaceControl != NULL);
49        ASSERT_TRUE(mSurfaceControl->isValid());
50
51        SurfaceComposerClient::openGlobalTransaction();
52        ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff));
53        ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
54        SurfaceComposerClient::closeGlobalTransaction();
55
56        mSurface = mSurfaceControl->getSurface();
57        ASSERT_TRUE(mSurface != NULL);
58    }
59
60    virtual void TearDown() {
61        mComposerClient->dispose();
62    }
63
64    sp<Surface> mSurface;
65    sp<SurfaceComposerClient> mComposerClient;
66    sp<SurfaceControl> mSurfaceControl;
67};
68
69TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
70    sp<ANativeWindow> anw(mSurface);
71    int result = -123;
72    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
73            &result);
74    EXPECT_EQ(NO_ERROR, err);
75    EXPECT_EQ(1, result);
76}
77
78TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
79    mSurfaceControl.clear();
80
81    sp<ANativeWindow> anw(mSurface);
82    int result = -123;
83    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
84            &result);
85    EXPECT_EQ(NO_ERROR, err);
86    EXPECT_EQ(1, result);
87}
88
89// This test probably doesn't belong here.
90TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) {
91    sp<ANativeWindow> anw(mSurface);
92
93    // Verify the screenshot works with no protected buffers.
94    sp<IGraphicBufferProducer> producer;
95    sp<IGraphicBufferConsumer> consumer;
96    BufferQueue::createBufferQueue(&producer, &consumer);
97    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
98    sp<ISurfaceComposer> sf(ComposerService::getComposerService());
99    sp<IBinder> display(sf->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
100    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
101            64, 64, 0, 0x7fffffff, false));
102
103    ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
104            NATIVE_WINDOW_API_CPU));
105    // Set the PROTECTED usage bit and verify that the screenshot fails.  Note
106    // that we need to dequeue a buffer in order for it to actually get
107    // allocated in SurfaceFlinger.
108    ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
109            GRALLOC_USAGE_PROTECTED));
110    ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
111    ANativeWindowBuffer* buf = 0;
112
113    status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
114    if (err) {
115        // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
116        // that's okay as long as this is the reason for the failure.
117        // try again without the GRALLOC_USAGE_PROTECTED bit.
118        ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
119        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
120                &buf));
121        return;
122    }
123    ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
124
125    for (int i = 0; i < 4; i++) {
126        // Loop to make sure SurfaceFlinger has retired a protected buffer.
127        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
128                &buf));
129        ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
130    }
131    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
132            64, 64, 0, 0x7fffffff, false));
133}
134
135TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
136    sp<ANativeWindow> anw(mSurface);
137    int result = -123;
138    int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
139    EXPECT_EQ(NO_ERROR, err);
140    EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
141}
142
143TEST_F(SurfaceTest, QueryConsumerUsage) {
144    const int TEST_USAGE_FLAGS =
145            GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
146    sp<IGraphicBufferProducer> producer;
147    sp<IGraphicBufferConsumer> consumer;
148    BufferQueue::createBufferQueue(&producer, &consumer);
149    sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
150            TEST_USAGE_FLAGS);
151    sp<Surface> s = new Surface(producer);
152
153    sp<ANativeWindow> anw(s);
154
155    int flags = -1;
156    int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
157
158    ASSERT_EQ(NO_ERROR, err);
159    ASSERT_EQ(TEST_USAGE_FLAGS, flags);
160}
161
162TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
163    const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB;
164    sp<IGraphicBufferProducer> producer;
165    sp<IGraphicBufferConsumer> consumer;
166    BufferQueue::createBufferQueue(&producer, &consumer);
167    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
168
169    cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
170
171    sp<Surface> s = new Surface(producer);
172
173    sp<ANativeWindow> anw(s);
174
175    android_dataspace dataSpace;
176
177    int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
178            reinterpret_cast<int*>(&dataSpace));
179
180    ASSERT_EQ(NO_ERROR, err);
181    ASSERT_EQ(TEST_DATASPACE, dataSpace);
182}
183
184TEST_F(SurfaceTest, SettingGenerationNumber) {
185    sp<IGraphicBufferProducer> producer;
186    sp<IGraphicBufferConsumer> consumer;
187    BufferQueue::createBufferQueue(&producer, &consumer);
188    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
189    sp<Surface> surface = new Surface(producer);
190    sp<ANativeWindow> window(surface);
191
192    // Allocate a buffer with a generation number of 0
193    ANativeWindowBuffer* buffer;
194    int fenceFd;
195    ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
196            NATIVE_WINDOW_API_CPU));
197    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
198    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
199
200    // Detach the buffer and check its generation number
201    sp<GraphicBuffer> graphicBuffer;
202    sp<Fence> fence;
203    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
204    ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
205
206    ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
207    buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
208
209    // This should change the generation number of the GraphicBuffer
210    ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
211
212    // Check that the new generation number sticks with the buffer
213    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
214    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
215    graphicBuffer = static_cast<GraphicBuffer*>(buffer);
216    ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
217}
218
219TEST_F(SurfaceTest, GetConsumerName) {
220    sp<IGraphicBufferProducer> producer;
221    sp<IGraphicBufferConsumer> consumer;
222    BufferQueue::createBufferQueue(&producer, &consumer);
223
224    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
225    consumer->consumerConnect(dummyConsumer, false);
226    consumer->setConsumerName(String8("TestConsumer"));
227
228    sp<Surface> surface = new Surface(producer);
229    sp<ANativeWindow> window(surface);
230    native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
231
232    EXPECT_STREQ("TestConsumer", surface->getConsumerName().string());
233}
234
235TEST_F(SurfaceTest, DynamicSetBufferCount) {
236    sp<IGraphicBufferProducer> producer;
237    sp<IGraphicBufferConsumer> consumer;
238    BufferQueue::createBufferQueue(&producer, &consumer);
239
240    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
241    consumer->consumerConnect(dummyConsumer, false);
242    consumer->setConsumerName(String8("TestConsumer"));
243
244    sp<Surface> surface = new Surface(producer);
245    sp<ANativeWindow> window(surface);
246
247    ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
248            NATIVE_WINDOW_API_CPU));
249    native_window_set_buffer_count(window.get(), 4);
250
251    int fence;
252    ANativeWindowBuffer* buffer;
253    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
254    native_window_set_buffer_count(window.get(), 3);
255    ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
256    native_window_set_buffer_count(window.get(), 2);
257    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
258    ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
259}
260
261}
262