Styjun

I am writing a game for Android using the Java for the user interface and C++ with the NDK for the render thread. It uses Vulkan if available and otherwise uses OpenGL ES. This bug occurs in OpenGL ES and Vulkan.

If I pause the app and quickly resume it before either onPause, onStop, or SurfaceHolder.Callback.surfaceDestroyed completes, then there will be an afterimage of what was shown on the surface immediately before the render thread stops. The afterimage behaves like a background to any new thing I draw. When performing the render pass I set the clear color to: black with 0.0 for alpha. I do this so that the app's background will be the background for the game. If I set the alpha value to 1.0, then the symptoms of this bug will not present themselves.

This problem can be viewed as a generalization of the problem described in:
phantom images after going from split screen to full screen
But the solution to that problem (i.e. avoiding shutting down the app) will not work for this more general case.

I am stopping the render thread during onPause or SurfaceHolder.Callback.surfaceDestroyed, which ever one happens first. These functions will not return until the render thread is joined (if there is one).

If I clear the screen by using an empty render pass with the clear color being black and 0.0 for alpha (in Vulkan) or by calling glClear (in OpenGL ES) before the render thread shuts down, then the bug does not manifest. But this stinks of something being done wrong with the surface (or perhaps some sort of race condition). I am worried that this solution just hides the bug instead of fixing it by freeing the resources associated with the afterimage. Is there something else I need to do to ensure that the surface is reset correctly?

Beginning the render pass (vulkan):

std::array<VkClearValue, 2> clearValues = ;
clearValues[0].color = 0.0f, 0.0f, 0.0f, 0.0f;
clearValues[1].depthStencil = 1.0, 0;
renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
renderPassInfo.pClearValues = clearValues.data();
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);

During initialization in OpenGL ES:

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

clearing the screen in the drawing loop (OpenGL):

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

In the render thread, this is the set up and tear down of the ANativeWindow. I checked in the debugger that the shared pointer deleter was actually called:

ANativeWindow *window = ANativeWindow_fromSurface(env, jsurface);
if (window == nullptr) 
 notify->sendError("Unable to acquire window from surface.");
 return;


auto deleter = [](WindowType *windowRaw) 
 /* release the java window object */
 if (windowRaw != nullptr) 
 ANativeWindow_release(windowRaw);
 
;
std::shared_ptr<WindowType> surface(window, deleter);

in onPause and SurfaceHolder.Callback.surfaceDestroyed:

if (drawer == null) 
 return;


try 
 Draw.tellDrawerStop();
 drawer.join();
 catch (InterruptedException e) 

drawer = null;

The following is done in onCreate to make the SurfaceView see through:

SurfaceView drawSurfaceView = findViewById(R.id.drawingSurface);
drawSurfaceView.setZOrderOnTop(true);
SurfaceHolder drawSurfaceHolder = drawSurfaceView.getHolder();
drawSurfaceHolder.setFormat(PixelFormat.TRANSPARENT);
drawSurfaceHolder.addCallback(new MySurfaceCallback(this));