478 lines
17 KiB
C++
478 lines
17 KiB
C++
/*
|
|
* Copyright 2013 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "SRGB_test"
|
|
//#define LOG_NDEBUG 0
|
|
|
|
#include "GLTest.h"
|
|
|
|
#include <gui/CpuConsumer.h>
|
|
#include <gui/Surface.h>
|
|
#include <gui/SurfaceComposerClient.h>
|
|
|
|
#include <EGL/egl.h>
|
|
#include <EGL/eglext.h>
|
|
#include <GLES3/gl3.h>
|
|
|
|
#include <android/native_window.h>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
namespace android {
|
|
|
|
class SRGBTest : public ::testing::Test {
|
|
protected:
|
|
// Class constants
|
|
enum {
|
|
DISPLAY_WIDTH = 512,
|
|
DISPLAY_HEIGHT = 512,
|
|
PIXEL_SIZE = 4, // bytes or components
|
|
DISPLAY_SIZE = DISPLAY_WIDTH * DISPLAY_HEIGHT * PIXEL_SIZE,
|
|
ALPHA_VALUE = 223, // should be in [0, 255]
|
|
TOLERANCE = 1,
|
|
};
|
|
static const char SHOW_DEBUG_STRING[];
|
|
|
|
SRGBTest() :
|
|
mInputSurface(), mCpuConsumer(), mLockedBuffer(),
|
|
mEglDisplay(EGL_NO_DISPLAY), mEglConfig(),
|
|
mEglContext(EGL_NO_CONTEXT), mEglSurface(EGL_NO_SURFACE),
|
|
mComposerClient(), mSurfaceControl(), mOutputSurface() {
|
|
}
|
|
|
|
virtual ~SRGBTest() {
|
|
if (mEglDisplay != EGL_NO_DISPLAY) {
|
|
if (mEglSurface != EGL_NO_SURFACE) {
|
|
eglDestroySurface(mEglDisplay, mEglSurface);
|
|
}
|
|
if (mEglContext != EGL_NO_CONTEXT) {
|
|
eglDestroyContext(mEglDisplay, mEglContext);
|
|
}
|
|
eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
EGL_NO_CONTEXT);
|
|
eglTerminate(mEglDisplay);
|
|
}
|
|
}
|
|
|
|
virtual void SetUp() {
|
|
sp<IGraphicBufferProducer> producer;
|
|
sp<IGraphicBufferConsumer> consumer;
|
|
BufferQueue::createBufferQueue(&producer, &consumer);
|
|
ASSERT_EQ(NO_ERROR, consumer->setDefaultBufferSize(
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT));
|
|
mCpuConsumer = new CpuConsumer(consumer, 1);
|
|
String8 name("CpuConsumer_for_SRGBTest");
|
|
mCpuConsumer->setName(name);
|
|
mInputSurface = new Surface(producer);
|
|
|
|
ASSERT_NO_FATAL_FAILURE(createEGLSurface(mInputSurface.get()));
|
|
ASSERT_NO_FATAL_FAILURE(createDebugSurface());
|
|
}
|
|
|
|
virtual void TearDown() {
|
|
ASSERT_NO_FATAL_FAILURE(copyToDebugSurface());
|
|
ASSERT_TRUE(mLockedBuffer.data != NULL);
|
|
ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
|
|
}
|
|
|
|
static float linearToSRGB(float l) {
|
|
if (l <= 0.0031308f) {
|
|
return l * 12.92f;
|
|
} else {
|
|
return 1.055f * pow(l, (1 / 2.4f)) - 0.055f;
|
|
}
|
|
}
|
|
|
|
static float srgbToLinear(float s) {
|
|
if (s <= 0.04045) {
|
|
return s / 12.92f;
|
|
} else {
|
|
return pow(((s + 0.055f) / 1.055f), 2.4f);
|
|
}
|
|
}
|
|
|
|
static uint8_t srgbToLinear(uint8_t u) {
|
|
float f = u / 255.0f;
|
|
return static_cast<uint8_t>(srgbToLinear(f) * 255.0f + 0.5f);
|
|
}
|
|
|
|
void fillTexture(bool writeAsSRGB) {
|
|
uint8_t* textureData = new uint8_t[DISPLAY_SIZE];
|
|
|
|
for (int y = 0; y < DISPLAY_HEIGHT; ++y) {
|
|
for (int x = 0; x < DISPLAY_WIDTH; ++x) {
|
|
float realValue = static_cast<float>(x) / (DISPLAY_WIDTH - 1);
|
|
realValue *= ALPHA_VALUE / 255.0f; // Premultiply by alpha
|
|
if (writeAsSRGB) {
|
|
realValue = linearToSRGB(realValue);
|
|
}
|
|
|
|
int offset = (y * DISPLAY_WIDTH + x) * PIXEL_SIZE;
|
|
for (int c = 0; c < 3; ++c) {
|
|
uint8_t intValue = static_cast<uint8_t>(
|
|
realValue * 255.0f + 0.5f);
|
|
textureData[offset + c] = intValue;
|
|
}
|
|
textureData[offset + 3] = ALPHA_VALUE;
|
|
}
|
|
}
|
|
|
|
glTexImage2D(GL_TEXTURE_2D, 0, writeAsSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA8,
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE,
|
|
textureData);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
|
|
delete[] textureData;
|
|
}
|
|
|
|
void initShaders() {
|
|
static const char vertexSource[] =
|
|
"attribute vec4 vPosition;\n"
|
|
"varying vec2 texCoords;\n"
|
|
"void main() {\n"
|
|
" texCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
|
|
" gl_Position = vPosition;\n"
|
|
"}\n";
|
|
|
|
static const char fragmentSource[] =
|
|
"precision mediump float;\n"
|
|
"uniform sampler2D texSampler;\n"
|
|
"varying vec2 texCoords;\n"
|
|
"void main() {\n"
|
|
" gl_FragColor = texture2D(texSampler, texCoords);\n"
|
|
"}\n";
|
|
|
|
GLuint program;
|
|
{
|
|
SCOPED_TRACE("Creating shader program");
|
|
ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(
|
|
vertexSource, fragmentSource, &program));
|
|
}
|
|
|
|
GLint positionHandle = glGetAttribLocation(program, "vPosition");
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
ASSERT_NE(-1, positionHandle);
|
|
|
|
GLint samplerHandle = glGetUniformLocation(program, "texSampler");
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
ASSERT_NE(-1, samplerHandle);
|
|
|
|
static const GLfloat vertices[] = {
|
|
-1.0f, 1.0f,
|
|
-1.0f, -1.0f,
|
|
1.0f, -1.0f,
|
|
1.0f, 1.0f,
|
|
};
|
|
|
|
glVertexAttribPointer(positionHandle, 2, GL_FLOAT, GL_FALSE, 0, vertices);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glEnableVertexAttribArray(positionHandle);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
|
|
glUseProgram(program);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glUniform1i(samplerHandle, 0);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
|
|
GLuint textureHandle;
|
|
glGenTextures(1, &textureHandle);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glBindTexture(GL_TEXTURE_2D, textureHandle);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
}
|
|
|
|
void drawTexture(bool asSRGB, GLint x, GLint y, GLsizei width,
|
|
GLsizei height) {
|
|
ASSERT_NO_FATAL_FAILURE(fillTexture(asSRGB));
|
|
glViewport(x, y, width, height);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
|
ASSERT_EQ(GL_NO_ERROR, glGetError());
|
|
}
|
|
|
|
void checkLockedBuffer(PixelFormat format) {
|
|
ASSERT_EQ(mLockedBuffer.format, format);
|
|
ASSERT_EQ(mLockedBuffer.width, DISPLAY_WIDTH);
|
|
ASSERT_EQ(mLockedBuffer.height, DISPLAY_HEIGHT);
|
|
}
|
|
|
|
static bool withinTolerance(int a, int b) {
|
|
int diff = a - b;
|
|
return diff >= 0 ? diff <= TOLERANCE : -diff <= TOLERANCE;
|
|
}
|
|
|
|
// Primary producer and consumer
|
|
sp<Surface> mInputSurface;
|
|
sp<CpuConsumer> mCpuConsumer;
|
|
CpuConsumer::LockedBuffer mLockedBuffer;
|
|
|
|
EGLDisplay mEglDisplay;
|
|
EGLConfig mEglConfig;
|
|
EGLContext mEglContext;
|
|
EGLSurface mEglSurface;
|
|
|
|
// Auxiliary display output
|
|
sp<SurfaceComposerClient> mComposerClient;
|
|
sp<SurfaceControl> mSurfaceControl;
|
|
sp<Surface> mOutputSurface;
|
|
|
|
private:
|
|
void createEGLSurface(Surface* inputSurface) {
|
|
mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay);
|
|
|
|
EXPECT_TRUE(eglInitialize(mEglDisplay, NULL, NULL));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
static const EGLint configAttribs[] = {
|
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
|
|
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT_KHR,
|
|
EGL_RED_SIZE, 8,
|
|
EGL_GREEN_SIZE, 8,
|
|
EGL_BLUE_SIZE, 8,
|
|
EGL_ALPHA_SIZE, 8,
|
|
EGL_NONE };
|
|
|
|
EGLint numConfigs = 0;
|
|
EXPECT_TRUE(eglChooseConfig(mEglDisplay, configAttribs, &mEglConfig, 1,
|
|
&numConfigs));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
ASSERT_GT(numConfigs, 0);
|
|
|
|
static const EGLint contextAttribs[] = {
|
|
EGL_CONTEXT_CLIENT_VERSION, 3,
|
|
EGL_NONE } ;
|
|
|
|
mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT,
|
|
contextAttribs);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
ASSERT_NE(EGL_NO_CONTEXT, mEglContext);
|
|
|
|
mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
|
|
inputSurface, NULL);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
|
|
|
|
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
|
|
mEglContext));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
}
|
|
|
|
void createDebugSurface() {
|
|
if (getenv(SHOW_DEBUG_STRING) == NULL) return;
|
|
|
|
mComposerClient = new SurfaceComposerClient;
|
|
ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
|
|
|
|
mSurfaceControl = mComposerClient->createSurface(
|
|
String8("SRGBTest Surface"), DISPLAY_WIDTH, DISPLAY_HEIGHT,
|
|
PIXEL_FORMAT_RGBA_8888);
|
|
|
|
ASSERT_TRUE(mSurfaceControl != NULL);
|
|
ASSERT_TRUE(mSurfaceControl->isValid());
|
|
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF));
|
|
ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
|
|
SurfaceComposerClient::closeGlobalTransaction();
|
|
|
|
ANativeWindow_Buffer outBuffer;
|
|
ARect inOutDirtyBounds;
|
|
mOutputSurface = mSurfaceControl->getSurface();
|
|
mOutputSurface->lock(&outBuffer, &inOutDirtyBounds);
|
|
uint8_t* bytePointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
|
|
for (int y = 0; y < outBuffer.height; ++y) {
|
|
int rowOffset = y * outBuffer.stride; // pixels
|
|
for (int x = 0; x < outBuffer.width; ++x) {
|
|
int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
|
|
for (int c = 0; c < PIXEL_SIZE; ++c) {
|
|
int offset = colOffset + c;
|
|
bytePointer[offset] = ((c + 1) * 56) - 1;
|
|
}
|
|
}
|
|
}
|
|
mOutputSurface->unlockAndPost();
|
|
}
|
|
|
|
void copyToDebugSurface() {
|
|
if (!mOutputSurface.get()) return;
|
|
|
|
size_t bufferSize = mLockedBuffer.height * mLockedBuffer.stride *
|
|
PIXEL_SIZE;
|
|
|
|
ANativeWindow_Buffer outBuffer;
|
|
ARect outBufferBounds;
|
|
mOutputSurface->lock(&outBuffer, &outBufferBounds);
|
|
ASSERT_EQ(mLockedBuffer.width, outBuffer.width);
|
|
ASSERT_EQ(mLockedBuffer.height, outBuffer.height);
|
|
ASSERT_EQ(mLockedBuffer.stride, outBuffer.stride);
|
|
|
|
if (mLockedBuffer.format == outBuffer.format) {
|
|
memcpy(outBuffer.bits, mLockedBuffer.data, bufferSize);
|
|
} else {
|
|
ASSERT_EQ(mLockedBuffer.format, PIXEL_FORMAT_sRGB_A_8888);
|
|
ASSERT_EQ(outBuffer.format, PIXEL_FORMAT_RGBA_8888);
|
|
uint8_t* outPointer = reinterpret_cast<uint8_t*>(outBuffer.bits);
|
|
for (int y = 0; y < outBuffer.height; ++y) {
|
|
int rowOffset = y * outBuffer.stride; // pixels
|
|
for (int x = 0; x < outBuffer.width; ++x) {
|
|
int colOffset = (rowOffset + x) * PIXEL_SIZE; // bytes
|
|
|
|
// RGB are converted
|
|
for (int c = 0; c < (PIXEL_SIZE - 1); ++c) {
|
|
outPointer[colOffset + c] = srgbToLinear(
|
|
mLockedBuffer.data[colOffset + c]);
|
|
}
|
|
|
|
// Alpha isn't converted
|
|
outPointer[colOffset + 3] =
|
|
mLockedBuffer.data[colOffset + 3];
|
|
}
|
|
}
|
|
}
|
|
mOutputSurface->unlockAndPost();
|
|
|
|
int sleepSeconds = atoi(getenv(SHOW_DEBUG_STRING));
|
|
sleep(sleepSeconds);
|
|
}
|
|
};
|
|
|
|
const char SRGBTest::SHOW_DEBUG_STRING[] = "DEBUG_OUTPUT_SECONDS";
|
|
|
|
TEST_F(SRGBTest, GLRenderFromSRGBTexture) {
|
|
ASSERT_NO_FATAL_FAILURE(initShaders());
|
|
|
|
// The RGB texture is displayed in the top half
|
|
ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, DISPLAY_HEIGHT / 2,
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));
|
|
|
|
// The SRGB texture is displayed in the bottom half
|
|
ASSERT_NO_FATAL_FAILURE(drawTexture(true, 0, 0,
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT / 2));
|
|
|
|
eglSwapBuffers(mEglDisplay, mEglSurface);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
// Lock
|
|
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
|
|
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));
|
|
|
|
// Compare a pixel in the middle of each texture
|
|
int midSRGBOffset = (DISPLAY_HEIGHT / 4) * mLockedBuffer.stride *
|
|
PIXEL_SIZE;
|
|
int midRGBOffset = midSRGBOffset * 3;
|
|
midRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
|
|
midSRGBOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
|
|
for (int c = 0; c < PIXEL_SIZE; ++c) {
|
|
int expectedValue = mLockedBuffer.data[midRGBOffset + c];
|
|
int actualValue = mLockedBuffer.data[midSRGBOffset + c];
|
|
ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
|
|
}
|
|
|
|
// mLockedBuffer is unlocked in TearDown so we can copy data from it to
|
|
// the debug surface if necessary
|
|
}
|
|
|
|
TEST_F(SRGBTest, RenderToSRGBSurface) {
|
|
ASSERT_NO_FATAL_FAILURE(initShaders());
|
|
|
|
// By default, the first buffer we write into will be RGB
|
|
|
|
// Render an RGB texture across the whole surface
|
|
ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT));
|
|
eglSwapBuffers(mEglDisplay, mEglSurface);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
// Lock
|
|
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
|
|
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_RGBA_8888));
|
|
|
|
// Save the values of the middle pixel for later comparison against SRGB
|
|
uint8_t values[PIXEL_SIZE] = {};
|
|
int middleOffset = (DISPLAY_HEIGHT / 2) * mLockedBuffer.stride *
|
|
PIXEL_SIZE;
|
|
middleOffset += (DISPLAY_WIDTH / 2) * PIXEL_SIZE;
|
|
for (int c = 0; c < PIXEL_SIZE; ++c) {
|
|
values[c] = mLockedBuffer.data[middleOffset + c];
|
|
}
|
|
|
|
// Unlock
|
|
ASSERT_EQ(NO_ERROR, mCpuConsumer->unlockBuffer(mLockedBuffer));
|
|
|
|
// Switch to SRGB window surface
|
|
#define EGL_GL_COLORSPACE_KHR EGL_VG_COLORSPACE
|
|
#define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB
|
|
|
|
static const int srgbAttribs[] = {
|
|
EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR,
|
|
EGL_NONE,
|
|
};
|
|
|
|
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
|
|
mEglContext));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
EXPECT_TRUE(eglDestroySurface(mEglDisplay, mEglSurface));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig,
|
|
mInputSurface.get(), srgbAttribs);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
ASSERT_NE(EGL_NO_SURFACE, mEglSurface);
|
|
|
|
EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
|
|
mEglContext));
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
// Render the texture again
|
|
ASSERT_NO_FATAL_FAILURE(drawTexture(false, 0, 0,
|
|
DISPLAY_WIDTH, DISPLAY_HEIGHT));
|
|
eglSwapBuffers(mEglDisplay, mEglSurface);
|
|
ASSERT_EQ(EGL_SUCCESS, eglGetError());
|
|
|
|
// Lock
|
|
ASSERT_EQ(NO_ERROR, mCpuConsumer->lockNextBuffer(&mLockedBuffer));
|
|
|
|
// Make sure we actually got the SRGB buffer on the consumer side
|
|
ASSERT_NO_FATAL_FAILURE(checkLockedBuffer(PIXEL_FORMAT_sRGB_A_8888));
|
|
|
|
// Verify that the stored value is the same, accounting for RGB/SRGB
|
|
for (int c = 0; c < PIXEL_SIZE; ++c) {
|
|
// The alpha value should be equivalent before linear->SRGB
|
|
float rgbAsSRGB = (c == 3) ? values[c] / 255.0f :
|
|
linearToSRGB(values[c] / 255.0f);
|
|
int expectedValue = rgbAsSRGB * 255.0f + 0.5f;
|
|
int actualValue = mLockedBuffer.data[middleOffset + c];
|
|
ASSERT_PRED2(withinTolerance, expectedValue, actualValue);
|
|
}
|
|
|
|
// mLockedBuffer is unlocked in TearDown so we can copy data from it to
|
|
// the debug surface if necessary
|
|
}
|
|
|
|
} // namespace android
|