packages/SystemUI/src/com/android/systemui/ImageWallpaper.java

   1 /*
   2  * Copyright (C) 2009 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 package com.android.systemui;
  18
  19 import static android.opengl.GLES20.*;
  20
  21 import static javax.microedition.khronos.egl.EGL10.*;
  22
  23 import android.app.ActivityManager;
  24 import android.app.WallpaperManager;
  25 import android.content.ComponentCallbacks2;
  26 import android.graphics.Bitmap;
  27 import android.graphics.Canvas;
  28 import android.graphics.Rect;
  29 import android.graphics.RectF;
  30 import android.graphics.Region.Op;
  31 import android.opengl.GLUtils;
  32 import android.os.AsyncTask;
  33 import android.os.SystemProperties;
  34 import android.os.Trace;
  35 import android.renderscript.Matrix4f;
  36 import android.service.wallpaper.WallpaperService;
  37 import android.util.Log;
  38 import android.view.Display;
  39 import android.view.DisplayInfo;
  40 import android.view.MotionEvent;
  41 import android.view.SurfaceHolder;
  42 import android.view.WindowManager;
  43
  44 import java.io.FileDescriptor;
  45 import java.io.IOException;
  46 import java.io.PrintWriter;
  47 import java.nio.ByteBuffer;
  48 import java.nio.ByteOrder;
  49 import java.nio.FloatBuffer;
  50
  51 import javax.microedition.khronos.egl.EGL10;
  52 import javax.microedition.khronos.egl.EGLConfig;
  53 import javax.microedition.khronos.egl.EGLContext;
  54 import javax.microedition.khronos.egl.EGLDisplay;
  55 import javax.microedition.khronos.egl.EGLSurface;
  56
  57 /**
  58  * Default built-in wallpaper that simply shows a static image.
  59  */
  60 @SuppressWarnings({"UnusedDeclaration"})
  61 public class ImageWallpaper extends WallpaperService {
  62     private static final String TAG = "ImageWallpaper";
  63     private static final String GL_LOG_TAG = "ImageWallpaperGL";
  64     private static final boolean DEBUG = false;
  65     private static final String PROPERTY_KERNEL_QEMU = "ro.kernel.qemu";
  66
  67     static final boolean FIXED_SIZED_SURFACE = true;
  68     static final boolean USE_OPENGL = true;
  69
  70     WallpaperManager mWallpaperManager;
  71
  72     DrawableEngine mEngine;
  73
  74     boolean mIsHwAccelerated;
  75
  76     @Override
  77     public void onCreate() {
  78         super.onCreate();
  79         mWallpaperManager = (WallpaperManager) getSystemService(WALLPAPER_SERVICE);
  80
  81         //noinspection PointlessBooleanExpression,ConstantConditions
  82         if (FIXED_SIZED_SURFACE && USE_OPENGL) {
  83             mIsHwAccelerated = ActivityManager.isHighEndGfx();
  84         }
  85     }
  86
  87     @Override
  88     public void onTrimMemory(int level) {
  89         if (mEngine != null) {
  90             mEngine.trimMemory(level);
  91         }
  92     }
  93
  94     @Override
  95     public Engine onCreateEngine() {
  96         mEngine = new DrawableEngine();
  97         return mEngine;
  98     }
  99
 100     class DrawableEngine extends Engine {
 101         static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
 102         static final int EGL_OPENGL_ES2_BIT = 4;
 103
 104         Bitmap mBackground;
 105         int mBackgroundWidth = -1, mBackgroundHeight = -1;
 106         int mLastSurfaceWidth = -1, mLastSurfaceHeight = -1;
 107         int mLastRotation = -1;
 108         float mXOffset = 0.5f;
 109         float mYOffset = 0.5f;
 110         float mScale = 1f;
 111
 112         private Display mDefaultDisplay;
 113         private final DisplayInfo mTmpDisplayInfo = new DisplayInfo();
 114
 115         boolean mVisible = true;
 116         boolean mOffsetsChanged;
 117         int mLastXTranslation;
 118         int mLastYTranslation;
 119
 120         private EGL10 mEgl;
 121         private EGLDisplay mEglDisplay;
 122         private EGLConfig mEglConfig;
 123         private EGLContext mEglContext;
 124         private EGLSurface mEglSurface;
 125
 126         private static final String sSimpleVS =
 127                 "attribute vec4 position;\n" +
 128                 "attribute vec2 texCoords;\n" +
 129                 "varying vec2 outTexCoords;\n" +
 130                 "uniform mat4 projection;\n" +
 131                 "\nvoid main(void) {\n" +
 132                 "    outTexCoords = texCoords;\n" +
 133                 "    gl_Position = projection * position;\n" +
 134                 "}\n\n";
 135         private static final String sSimpleFS =
 136                 "precision mediump float;\n\n" +
 137                 "varying vec2 outTexCoords;\n" +
 138                 "uniform sampler2D texture;\n" +
 139                 "\nvoid main(void) {\n" +
 140                 "    gl_FragColor = texture2D(texture, outTexCoords);\n" +
 141                 "}\n\n";
 142
 143         private static final int FLOAT_SIZE_BYTES = 4;
 144         private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
 145         private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;
 146         private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;
 147
 148         private int mRotationAtLastSurfaceSizeUpdate = -1;
 149         private int mDisplayWidthAtLastSurfaceSizeUpdate = -1;
 150         private int mDisplayHeightAtLastSurfaceSizeUpdate = -1;
 151
 152         private int mLastRequestedWidth = -1;
 153         private int mLastRequestedHeight = -1;
 154         private AsyncTask<Void, Void, Bitmap> mLoader;
 155         private boolean mNeedsDrawAfterLoadingWallpaper;
 156         private boolean mSurfaceValid;
 157
 158         public DrawableEngine() {
 159             super();
 160             setFixedSizeAllowed(true);
 161         }
 162
 163         public void trimMemory(int level) {
 164             if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW
 165                     && level <= ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL
 166                     && mBackground != null) {
 167                 if (DEBUG) {
 168                     Log.d(TAG, "trimMemory");
 169                 }
 170                 unloadWallpaper(true /* forgetSize */);
 171             }
 172         }
 173
 174         @Override
 175         public void onCreate(SurfaceHolder surfaceHolder) {
 176             if (DEBUG) {
 177                 Log.d(TAG, "onCreate");
 178             }
 179
 180             super.onCreate(surfaceHolder);
 181
 182             mDefaultDisplay = getSystemService(WindowManager.class).getDefaultDisplay();
 183             setOffsetNotificationsEnabled(false);
 184
 185             updateSurfaceSize(surfaceHolder, getDefaultDisplayInfo(), false /* forDraw */);
 186         }
 187
 188         @Override
 189         public void onDestroy() {
 190             super.onDestroy();
 191             mBackground = null;
 192             unloadWallpaper(true /* forgetSize */);
 193         }
 194
 195         boolean updateSurfaceSize(SurfaceHolder surfaceHolder, DisplayInfo displayInfo,
 196                 boolean forDraw) {
 197             boolean hasWallpaper = true;
 198
 199             // Load background image dimensions, if we haven't saved them yet
 200             if (mBackgroundWidth <= 0 || mBackgroundHeight <= 0) {
 201                 // Need to load the image to get dimensions
 202                 loadWallpaper(forDraw, false /* needsReset */);
 203                 if (DEBUG) {
 204                     Log.d(TAG, "Reloading, redoing updateSurfaceSize later.");
 205                 }
 206                 hasWallpaper = false;
 207             }
 208
 209             // Force the wallpaper to cover the screen in both dimensions
 210             int surfaceWidth = Math.max(displayInfo.logicalWidth, mBackgroundWidth);
 211             int surfaceHeight = Math.max(displayInfo.logicalHeight, mBackgroundHeight);
 212
 213             if (FIXED_SIZED_SURFACE) {
 214                 // Used a fixed size surface, because we are special.  We can do
 215                 // this because we know the current design of window animations doesn't
 216                 // cause this to break.
 217                 surfaceHolder.setFixedSize(surfaceWidth, surfaceHeight);
 218                 mLastRequestedWidth = surfaceWidth;
 219                 mLastRequestedHeight = surfaceHeight;
 220             } else {
 221                 surfaceHolder.setSizeFromLayout();
 222             }
 223             return hasWallpaper;
 224         }
 225
 226         @Override
 227         public void onVisibilityChanged(boolean visible) {
 228             if (DEBUG) {
 229                 Log.d(TAG, "onVisibilityChanged: mVisible, visible=" + mVisible + ", " + visible);
 230             }
 231
 232             if (mVisible != visible) {
 233                 if (DEBUG) {
 234                     Log.d(TAG, "Visibility changed to visible=" + visible);
 235                 }
 236                 mVisible = visible;
 237                 if (visible) {
 238                     drawFrame();
 239                 }
 240             }
 241         }
 242
 243         @Override
 244         public void onOffsetsChanged(float xOffset, float yOffset,
 245                 float xOffsetStep, float yOffsetStep,
 246                 int xPixels, int yPixels) {
 247             if (DEBUG) {
 248                 Log.d(TAG, "onOffsetsChanged: xOffset=" + xOffset + ", yOffset=" + yOffset
 249                         + ", xOffsetStep=" + xOffsetStep + ", yOffsetStep=" + yOffsetStep
 250                         + ", xPixels=" + xPixels + ", yPixels=" + yPixels);
 251             }
 252
 253             if (mXOffset != xOffset || mYOffset != yOffset) {
 254                 if (DEBUG) {
 255                     Log.d(TAG, "Offsets changed to (" + xOffset + "," + yOffset + ").");
 256                 }
 257                 mXOffset = xOffset;
 258                 mYOffset = yOffset;
 259                 mOffsetsChanged = true;
 260             }
 261             drawFrame();
 262         }
 263
 264         @Override
 265         public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
 266             if (DEBUG) {
 267                 Log.d(TAG, "onSurfaceChanged: width=" + width + ", height=" + height);
 268             }
 269
 270             super.onSurfaceChanged(holder, format, width, height);
 271
 272             drawFrame();
 273         }
 274
 275         @Override
 276         public void onSurfaceDestroyed(SurfaceHolder holder) {
 277             super.onSurfaceDestroyed(holder);
 278             if (DEBUG) {
 279                 Log.i(TAG, "onSurfaceDestroyed");
 280             }
 281
 282             mLastSurfaceWidth = mLastSurfaceHeight = -1;
 283             mSurfaceValid = false;
 284         }
 285
 286         @Override
 287         public void onSurfaceCreated(SurfaceHolder holder) {
 288             super.onSurfaceCreated(holder);
 289             if (DEBUG) {
 290                 Log.i(TAG, "onSurfaceCreated");
 291             }
 292
 293             mLastSurfaceWidth = mLastSurfaceHeight = -1;
 294             mSurfaceValid = true;
 295         }
 296
 297         @Override
 298         public void onSurfaceRedrawNeeded(SurfaceHolder holder) {
 299             if (DEBUG) {
 300                 Log.d(TAG, "onSurfaceRedrawNeeded");
 301             }
 302             super.onSurfaceRedrawNeeded(holder);
 303             drawFrame();
 304         }
 305
 306         private DisplayInfo getDefaultDisplayInfo() {
 307             mDefaultDisplay.getDisplayInfo(mTmpDisplayInfo);
 308             return mTmpDisplayInfo;
 309         }
 310
 311         void drawFrame() {
 312             if (!mSurfaceValid) {
 313                 return;
 314             }
 315             try {
 316                 Trace.traceBegin(Trace.TRACE_TAG_VIEW, "drawWallpaper");
 317                 DisplayInfo displayInfo = getDefaultDisplayInfo();
 318                 int newRotation = displayInfo.rotation;
 319
 320                 // Sometimes a wallpaper is not large enough to cover the screen in one dimension.
 321                 // Call updateSurfaceSize -- it will only actually do the update if the dimensions
 322                 // should change
 323                 if (newRotation != mLastRotation) {
 324                     // Update surface size (if necessary)
 325                     if (!updateSurfaceSize(getSurfaceHolder(), displayInfo, true /* forDraw */)) {
 326                         return; // had to reload wallpaper, will retry later
 327                     }
 328                     mRotationAtLastSurfaceSizeUpdate = newRotation;
 329                     mDisplayWidthAtLastSurfaceSizeUpdate = displayInfo.logicalWidth;
 330                     mDisplayHeightAtLastSurfaceSizeUpdate = displayInfo.logicalHeight;
 331                 }
 332                 SurfaceHolder sh = getSurfaceHolder();
 333                 final Rect frame = sh.getSurfaceFrame();
 334                 final int dw = frame.width();
 335                 final int dh = frame.height();
 336                 boolean surfaceDimensionsChanged = dw != mLastSurfaceWidth
 337                         || dh != mLastSurfaceHeight;
 338
 339                 boolean redrawNeeded = surfaceDimensionsChanged || newRotation != mLastRotation;
 340                 if (!redrawNeeded && !mOffsetsChanged) {
 341                     if (DEBUG) {
 342                         Log.d(TAG, "Suppressed drawFrame since redraw is not needed "
 343                                 + "and offsets have not changed.");
 344                     }
 345                     return;
 346                 }
 347                 mLastRotation = newRotation;
 348
 349                 // Load bitmap if it is not yet loaded
 350                 if (mBackground == null) {
 351                     if (DEBUG) {
 352                         Log.d(TAG, "Reloading bitmap: mBackground, bgw, bgh, dw, dh = " +
 353                                 mBackground + ", " +
 354                                 ((mBackground == null) ? 0 : mBackground.getWidth()) + ", " +
 355                                 ((mBackground == null) ? 0 : mBackground.getHeight()) + ", " +
 356                                 dw + ", " + dh);
 357                     }
 358                     loadWallpaper(true /* needDraw */, true /* needReset */);
 359                     if (DEBUG) {
 360                         Log.d(TAG, "Reloading, resuming draw later");
 361                     }
 362                     return;
 363                 }
 364
 365                 // Center the scaled image
 366                 mScale = Math.max(1f, Math.max(dw / (float) mBackground.getWidth(),
 367                         dh / (float) mBackground.getHeight()));
 368                 final int availw = dw - (int) (mBackground.getWidth() * mScale);
 369                 final int availh = dh - (int) (mBackground.getHeight() * mScale);
 370                 int xPixels = availw / 2;
 371                 int yPixels = availh / 2;
 372
 373                 // Adjust the image for xOffset/yOffset values. If window manager is handling offsets,
 374                 // mXOffset and mYOffset are set to 0.5f by default and therefore xPixels and yPixels
 375                 // will remain unchanged
 376                 final int availwUnscaled = dw - mBackground.getWidth();
 377                 final int availhUnscaled = dh - mBackground.getHeight();
 378                 if (availwUnscaled < 0)
 379                     xPixels += (int) (availwUnscaled * (mXOffset - .5f) + .5f);
 380                 if (availhUnscaled < 0)
 381                     yPixels += (int) (availhUnscaled * (mYOffset - .5f) + .5f);
 382
 383                 mOffsetsChanged = false;
 384                 if (surfaceDimensionsChanged) {
 385                     mLastSurfaceWidth = dw;
 386                     mLastSurfaceHeight = dh;
 387                 }
 388                 if (!redrawNeeded && xPixels == mLastXTranslation && yPixels == mLastYTranslation) {
 389                     if (DEBUG) {
 390                         Log.d(TAG, "Suppressed drawFrame since the image has not "
 391                                 + "actually moved an integral number of pixels.");
 392                     }
 393                     return;
 394                 }
 395                 mLastXTranslation = xPixels;
 396                 mLastYTranslation = yPixels;
 397
 398                 if (DEBUG) {
 399                     Log.d(TAG, "Redrawing wallpaper");
 400                 }
 401
 402                 if (mIsHwAccelerated) {
 403                     if (!drawWallpaperWithOpenGL(sh, availw, availh, xPixels, yPixels)) {
 404                         drawWallpaperWithCanvas(sh, availw, availh, xPixels, yPixels);
 405                     }
 406                 } else {
 407                     drawWallpaperWithCanvas(sh, availw, availh, xPixels, yPixels);
 408                     if (FIXED_SIZED_SURFACE) {
 409                         // If the surface is fixed-size, we should only need to
 410                         // draw it once and then we'll let the window manager
 411                         // position it appropriately.  As such, we no longer needed
 412                         // the loaded bitmap.  Yay!
 413                         // hw-accelerated renderer retains bitmap for faster rotation
 414                         unloadWallpaper(false /* forgetSize */);
 415                     }
 416                 }
 417             } finally {
 418                 Trace.traceEnd(Trace.TRACE_TAG_VIEW);
 419             }
 420         }
 421
 422         /**
 423          * Loads the wallpaper on background thread and schedules updating the surface frame,
 424          * and if {@param needsDraw} is set also draws a frame.
 425          *
 426          * If loading is already in-flight, subsequent loads are ignored (but needDraw is or-ed to
 427          * the active request).
 428          *
 429          * If {@param needsReset} is set also clears the cache in WallpaperManager first.
 430          */
 431         private void loadWallpaper(boolean needsDraw, boolean needsReset) {
 432             mNeedsDrawAfterLoadingWallpaper |= needsDraw;
 433             if (mLoader != null) {
 434                 if (needsReset) {
 435                     mLoader.cancel(false /* interrupt */);
 436                     mLoader = null;
 437                 } else {
 438                     if (DEBUG) {
 439                         Log.d(TAG, "Skipping loadWallpaper, already in flight ");
 440                     }
 441                     return;
 442                 }
 443             }
 444             mLoader = new AsyncTask<Void, Void, Bitmap>() {
 445                 @Override
 446                 protected Bitmap doInBackground(Void... params) {
 447                     Throwable exception;
 448                     try {
 449                         if (needsReset) {
 450                             mWallpaperManager.forgetLoadedWallpaper();
 451                         }
 452                         return mWallpaperManager.getBitmap();
 453                     } catch (RuntimeException | OutOfMemoryError e) {
 454                         exception = e;
 455                     }
 456
 457                     if (isCancelled()) {
 458                         return null;
 459                     }
 460
 461                     if (exception != null) {
 462                         // Note that if we do fail at this, and the default wallpaper can't
 463                         // be loaded, we will go into a cycle.  Don't do a build where the
 464                         // default wallpaper can't be loaded.
 465                         Log.w(TAG, "Unable to load wallpaper!", exception);
 466                         try {
 467                             mWallpaperManager.clear();
 468                         } catch (IOException ex) {
 469                             // now we're really screwed.
 470                             Log.w(TAG, "Unable reset to default wallpaper!", ex);
 471                         }
 472
 473                         if (isCancelled()) {
 474                             return null;
 475                         }
 476
 477                         try {
 478                             return mWallpaperManager.getBitmap();
 479                         } catch (RuntimeException | OutOfMemoryError e) {
 480                             Log.w(TAG, "Unable to load default wallpaper!", e);
 481                         }
 482                     }
 483                     return null;
 484                 }
 485
 486                 @Override
 487                 protected void onPostExecute(Bitmap b) {
 488                     mBackground = null;
 489                     mBackgroundWidth = -1;
 490                     mBackgroundHeight = -1;
 491
 492                     if (b != null) {
 493                         mBackground = b;
 494                         mBackgroundWidth = mBackground.getWidth();
 495                         mBackgroundHeight = mBackground.getHeight();
 496                     }
 497
 498                     if (DEBUG) {
 499                         Log.d(TAG, "Wallpaper loaded: " + mBackground);
 500                     }
 501                     updateSurfaceSize(getSurfaceHolder(), getDefaultDisplayInfo(),
 502                             false /* forDraw */);
 503                     if (mNeedsDrawAfterLoadingWallpaper) {
 504                         drawFrame();
 505                     }
 506
 507                     mLoader = null;
 508                     mNeedsDrawAfterLoadingWallpaper = false;
 509                 }
 510             }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
 511         }
 512
 513         private void unloadWallpaper(boolean forgetSize) {
 514             if (mLoader != null) {
 515                 mLoader.cancel(false);
 516                 mLoader = null;
 517             }
 518             mBackground = null;
 519             if (forgetSize) {
 520                 mBackgroundWidth = -1;
 521                 mBackgroundHeight = -1;
 522             }
 523
 524             mLoader = new AsyncTask<Void, Void, Bitmap>() {
 525                 @Override
 526                 protected Bitmap doInBackground(Void... params) {
 527                     mWallpaperManager.forgetLoadedWallpaper();
 528                     return null;
 529                 }
 530             }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
 531         }
 532
 533         @Override
 534         protected void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {
 535             super.dump(prefix, fd, out, args);
 536
 537             out.print(prefix); out.println("ImageWallpaper.DrawableEngine:");
 538             out.print(prefix); out.print(" mBackground="); out.print(mBackground);
 539             out.print(" mBackgroundWidth="); out.print(mBackgroundWidth);
 540             out.print(" mBackgroundHeight="); out.println(mBackgroundHeight);
 541
 542             out.print(prefix); out.print(" mLastRotation="); out.print(mLastRotation);
 543             out.print(" mLastSurfaceWidth="); out.print(mLastSurfaceWidth);
 544             out.print(" mLastSurfaceHeight="); out.println(mLastSurfaceHeight);
 545
 546             out.print(prefix); out.print(" mXOffset="); out.print(mXOffset);
 547             out.print(" mYOffset="); out.println(mYOffset);
 548
 549             out.print(prefix); out.print(" mVisible="); out.print(mVisible);
 550             out.print(" mOffsetsChanged="); out.println(mOffsetsChanged);
 551
 552             out.print(prefix); out.print(" mLastXTranslation="); out.print(mLastXTranslation);
 553             out.print(" mLastYTranslation="); out.print(mLastYTranslation);
 554             out.print(" mScale="); out.println(mScale);
 555
 556             out.print(prefix); out.print(" mLastRequestedWidth="); out.print(mLastRequestedWidth);
 557             out.print(" mLastRequestedHeight="); out.println(mLastRequestedHeight);
 558
 559             out.print(prefix); out.println(" DisplayInfo at last updateSurfaceSize:");
 560             out.print(prefix);
 561             out.print("  rotation="); out.print(mRotationAtLastSurfaceSizeUpdate);
 562             out.print("  width="); out.print(mDisplayWidthAtLastSurfaceSizeUpdate);
 563             out.print("  height="); out.println(mDisplayHeightAtLastSurfaceSizeUpdate);
 564         }
 565
 566         private void drawWallpaperWithCanvas(SurfaceHolder sh, int w, int h, int left, int top) {
 567             Canvas c = sh.lockCanvas();
 568             if (c != null) {
 569                 try {
 570                     if (DEBUG) {
 571                         Log.d(TAG, "Redrawing: left=" + left + ", top=" + top);
 572                     }
 573
 574                     final float right = left + mBackground.getWidth() * mScale;
 575                     final float bottom = top + mBackground.getHeight() * mScale;
 576                     if (w < 0 || h < 0) {
 577                         c.save(Canvas.CLIP_SAVE_FLAG);
 578                         c.clipRect(left, top, right, bottom,
 579                                 Op.DIFFERENCE);
 580                         c.drawColor(0xff000000);
 581                         c.restore();
 582                     }
 583                     if (mBackground != null) {
 584                         RectF dest = new RectF(left, top, right, bottom);
 585                         // add a filter bitmap?
 586                         c.drawBitmap(mBackground, null, dest, null);
 587                     }
 588                 } finally {
 589                     sh.unlockCanvasAndPost(c);
 590                 }
 591             }
 592         }
 593
 594         private boolean drawWallpaperWithOpenGL(SurfaceHolder sh, int w, int h, int left, int top) {
 595             if (!initGL(sh)) return false;
 596
 597             final float right = left + mBackground.getWidth() * mScale;
 598             final float bottom = top + mBackground.getHeight() * mScale;
 599
 600             final Rect frame = sh.getSurfaceFrame();
 601             final Matrix4f ortho = new Matrix4f();
 602             ortho.loadOrtho(0.0f, frame.width(), frame.height(), 0.0f, -1.0f, 1.0f);
 603
 604             final FloatBuffer triangleVertices = createMesh(left, top, right, bottom);
 605
 606             final int texture = loadTexture(mBackground);
 607             final int program = buildProgram(sSimpleVS, sSimpleFS);
 608
 609             final int attribPosition = glGetAttribLocation(program, "position");
 610             final int attribTexCoords = glGetAttribLocation(program, "texCoords");
 611             final int uniformTexture = glGetUniformLocation(program, "texture");
 612             final int uniformProjection = glGetUniformLocation(program, "projection");
 613
 614             checkGlError();
 615
 616             glViewport(0, 0, frame.width(), frame.height());
 617             glBindTexture(GL_TEXTURE_2D, texture);
 618
 619             glUseProgram(program);
 620             glEnableVertexAttribArray(attribPosition);
 621             glEnableVertexAttribArray(attribTexCoords);
 622             glUniform1i(uniformTexture, 0);
 623             glUniformMatrix4fv(uniformProjection, 1, false, ortho.getArray(), 0);
 624
 625             checkGlError();
 626
 627             if (w > 0 || h > 0) {
 628                 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 629                 glClear(GL_COLOR_BUFFER_BIT);
 630             }
 631
 632             // drawQuad
 633             triangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
 634             glVertexAttribPointer(attribPosition, 3, GL_FLOAT, false,
 635                     TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);
 636
 637             triangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
 638             glVertexAttribPointer(attribTexCoords, 3, GL_FLOAT, false,
 639                     TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);
 640
 641             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 642
 643             boolean status = mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
 644             checkEglError();
 645
 646             finishGL(texture, program);
 647
 648             return status;
 649         }
 650
 651         private FloatBuffer createMesh(int left, int top, float right, float bottom) {
 652             final float[] verticesData = {
 653                     // X, Y, Z, U, V
 654                      left,  bottom, 0.0f, 0.0f, 1.0f,
 655                      right, bottom, 0.0f, 1.0f, 1.0f,
 656                      left,  top,    0.0f, 0.0f, 0.0f,
 657                      right, top,    0.0f, 1.0f, 0.0f,
 658             };
 659
 660             final int bytes = verticesData.length * FLOAT_SIZE_BYTES;
 661             final FloatBuffer triangleVertices = ByteBuffer.allocateDirect(bytes).order(
 662                     ByteOrder.nativeOrder()).asFloatBuffer();
 663             triangleVertices.put(verticesData).position(0);
 664             return triangleVertices;
 665         }
 666
 667         private int loadTexture(Bitmap bitmap) {
 668             int[] textures = new int[1];
 669
 670             glActiveTexture(GL_TEXTURE0);
 671             glGenTextures(1, textures, 0);
 672             checkGlError();
 673
 674             int texture = textures[0];
 675             glBindTexture(GL_TEXTURE_2D, texture);
 676             checkGlError();
 677
 678             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 679             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 680
 681             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 682             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 683
 684             GLUtils.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap, GL_UNSIGNED_BYTE, 0);
 685             checkGlError();
 686
 687             return texture;
 688         }
 689
 690         private int buildProgram(String vertex, String fragment) {
 691             int vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
 692             if (vertexShader == 0) return 0;
 693
 694             int fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
 695             if (fragmentShader == 0) return 0;
 696
 697             int program = glCreateProgram();
 698             glAttachShader(program, vertexShader);
 699             glAttachShader(program, fragmentShader);
 700             glLinkProgram(program);
 701             checkGlError();
 702
 703             glDeleteShader(vertexShader);
 704             glDeleteShader(fragmentShader);
 705
 706             int[] status = new int[1];
 707             glGetProgramiv(program, GL_LINK_STATUS, status, 0);
 708             if (status[0] != GL_TRUE) {
 709                 String error = glGetProgramInfoLog(program);
 710                 Log.d(GL_LOG_TAG, "Error while linking program:\n" + error);
 711                 glDeleteProgram(program);
 712                 return 0;
 713             }
 714
 715             return program;
 716         }
 717
 718         private int buildShader(String source, int type) {
 719             int shader = glCreateShader(type);
 720
 721             glShaderSource(shader, source);
 722             checkGlError();
 723
 724             glCompileShader(shader);
 725             checkGlError();
 726
 727             int[] status = new int[1];
 728             glGetShaderiv(shader, GL_COMPILE_STATUS, status, 0);
 729             if (status[0] != GL_TRUE) {
 730                 String error = glGetShaderInfoLog(shader);
 731                 Log.d(GL_LOG_TAG, "Error while compiling shader:\n" + error);
 732                 glDeleteShader(shader);
 733                 return 0;
 734             }
 735
 736             return shader;
 737         }
 738
 739         private void checkEglError() {
 740             int error = mEgl.eglGetError();
 741             if (error != EGL_SUCCESS) {
 742                 Log.w(GL_LOG_TAG, "EGL error = " + GLUtils.getEGLErrorString(error));
 743             }
 744         }
 745
 746         private void checkGlError() {
 747             int error = glGetError();
 748             if (error != GL_NO_ERROR) {
 749                 Log.w(GL_LOG_TAG, "GL error = 0x" + Integer.toHexString(error), new Throwable());
 750             }
 751         }
 752
 753         private void finishGL(int texture, int program) {
 754             int[] textures = new int[1];
 755             textures[0] = texture;
 756             glDeleteTextures(1, textures, 0);
 757             glDeleteProgram(program);
 758             mEgl.eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 759             mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
 760             mEgl.eglDestroyContext(mEglDisplay, mEglContext);
 761             mEgl.eglTerminate(mEglDisplay);
 762         }
 763
 764         private boolean initGL(SurfaceHolder surfaceHolder) {
 765             mEgl = (EGL10) EGLContext.getEGL();
 766
 767             mEglDisplay = mEgl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
 768             if (mEglDisplay == EGL_NO_DISPLAY) {
 769                 throw new RuntimeException("eglGetDisplay failed " +
 770                         GLUtils.getEGLErrorString(mEgl.eglGetError()));
 771             }
 772
 773             int[] version = new int[2];
 774             if (!mEgl.eglInitialize(mEglDisplay, version)) {
 775                 throw new RuntimeException("eglInitialize failed " +
 776                         GLUtils.getEGLErrorString(mEgl.eglGetError()));
 777             }
 778
 779             mEglConfig = chooseEglConfig();
 780             if (mEglConfig == null) {
 781                 return false;
 782             }
 783
 784             mEglContext = createContext(mEgl, mEglDisplay, mEglConfig);
 785             if (mEglContext == EGL_NO_CONTEXT) {
 786                 throw new RuntimeException("createContext failed " +
 787                         GLUtils.getEGLErrorString(mEgl.eglGetError()));
 788             }
 789
 790             int attribs[] = {
 791                 EGL_WIDTH, 1,
 792                 EGL_HEIGHT, 1,
 793                 EGL_NONE
 794             };
 795             EGLSurface tmpSurface = mEgl.eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
 796             mEgl.eglMakeCurrent(mEglDisplay, tmpSurface, tmpSurface, mEglContext);
 797
 798             int[] maxSize = new int[1];
 799             Rect frame = surfaceHolder.getSurfaceFrame();
 800             glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxSize, 0);
 801
 802             mEgl.eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 803             mEgl.eglDestroySurface(mEglDisplay, tmpSurface);
 804
 805             if(frame.width() > maxSize[0] || frame.height() > maxSize[0]) {
 806                 mEgl.eglDestroyContext(mEglDisplay, mEglContext);
 807                 mEgl.eglTerminate(mEglDisplay);
 808                 Log.e(GL_LOG_TAG, "requested  texture size " +
 809                     frame.width() + "x" + frame.height() + " exceeds the support maximum of " +
 810                     maxSize[0] + "x" + maxSize[0]);
 811                 return false;
 812             }
 813
 814             mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surfaceHolder, null);
 815             if (mEglSurface == null || mEglSurface == EGL_NO_SURFACE) {
 816                 int error = mEgl.eglGetError();
 817                 if (error == EGL_BAD_NATIVE_WINDOW || error == EGL_BAD_ALLOC) {
 818                     Log.e(GL_LOG_TAG, "createWindowSurface returned " +
 819                                          GLUtils.getEGLErrorString(error) + ".");
 820                     return false;
 821                 }
 822                 throw new RuntimeException("createWindowSurface failed " +
 823                         GLUtils.getEGLErrorString(error));
 824             }
 825
 826             if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
 827                 throw new RuntimeException("eglMakeCurrent failed " +
 828                         GLUtils.getEGLErrorString(mEgl.eglGetError()));
 829             }
 830
 831             return true;
 832         }
 833
 834
 835         EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
 836             int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
 837             return egl.eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, attrib_list);
 838         }
 839
 840         private EGLConfig chooseEglConfig() {
 841             int[] configsCount = new int[1];
 842             EGLConfig[] configs = new EGLConfig[1];
 843             int[] configSpec = getConfig();
 844             if (!mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, configsCount)) {
 845                 throw new IllegalArgumentException("eglChooseConfig failed " +
 846                         GLUtils.getEGLErrorString(mEgl.eglGetError()));
 847             } else if (configsCount[0] > 0) {
 848                 return configs[0];
 849             }
 850             return null;
 851         }
 852
 853         private int[] getConfig() {
 854             return new int[] {
 855                     EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 856                     EGL_RED_SIZE, 8,
 857                     EGL_GREEN_SIZE, 8,
 858                     EGL_BLUE_SIZE, 8,
 859                     EGL_ALPHA_SIZE, 0,
 860                     EGL_DEPTH_SIZE, 0,
 861                     EGL_STENCIL_SIZE, 0,
 862                     EGL_CONFIG_CAVEAT, EGL_NONE,
 863                     EGL_NONE
 864             };
 865         }
 866     }
 867 }