try to fix keyboardinput

forge-core/src/main/java/forge/util/ImageUtil.java

@@ -22,26 +22,10 @@ public class ImageUtil {
         }
         if (imageKey.startsWith(ImageKeys.CARD_PREFIX))
             key = imageKey.substring(ImageKeys.CARD_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.TOKEN_PREFIX))
+        else
-            key = imageKey.substring(ImageKeys.TOKEN_PREFIX.length());
+            return null;
-        else if (imageKey.startsWith(ImageKeys.ICON_PREFIX))
+        if (key.isEmpty())
-            key = imageKey.substring(ImageKeys.ICON_PREFIX.length());
+            return null;
-        else if (imageKey.startsWith(ImageKeys.BOOSTER_PREFIX))
-            key = imageKey.substring(ImageKeys.BOOSTER_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.FATPACK_PREFIX))
-            key = imageKey.substring(ImageKeys.FATPACK_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.BOOSTERBOX_PREFIX))
-            key = imageKey.substring(ImageKeys.BOOSTERBOX_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.PRECON_PREFIX))
-            key = imageKey.substring(ImageKeys.PRECON_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.TOURNAMENTPACK_PREFIX))
-            key = imageKey.substring(ImageKeys.TOURNAMENTPACK_PREFIX.length());
-        else if (imageKey.startsWith(ImageKeys.ADVENTURECARD_PREFIX))
-            key = imageKey.substring(ImageKeys.ADVENTURECARD_PREFIX.length());
-        else if (imageKey.contains(".full")) {//no prefix found, construct a valid key if imageKey is art imagekey.
-            key = transformKey(imageKey);
-        } else //try anyway...
-            key = imageKey;
 
         CardDb db = StaticData.instance().getCommonCards();
         PaperCard cp = null;

forge-gui-android/res/drawable/design_ic_visibility.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="NewApi"
+    android:height="24dp"
+    android:viewportHeight="24.0"
+    android:viewportWidth="24.0"
+    android:width="24dp">
+
+  <path
+      android:fillColor="#000000"
+      android:pathData="M12,4.5C7,4.5 2.73,7.61 1,12c1.73,4.39 6,7.5 11,7.5s9.27,-3.11 11,-7.5c-1.73,-4.39 -6,-7.5 -11,-7.5zM12,17c-2.76,0 -5,-2.24 -5,-5s2.24,-5 5,-5 5,2.24 5,5 -2.24,5 -5,5zM12,9c-1.66,0 -3,1.34 -3,3s1.34,3 3,3 3,-1.34 3,-3 -1.34,-3 -3,-3z"/>
+
+</vector>

forge-gui-android/res/drawable/design_ic_visibility_off.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 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.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="NewApi"
+    android:height="24dp"
+    android:viewportHeight="24"
+    android:viewportWidth="24"
+    android:width="24dp">
+
+  <path
+      android:fillColor="#000000"
+      android:pathData="M12,7c2.76,0 5,2.24 5,5 0,0.65 -0.13,1.26 -0.36,1.83l2.92,2.92c1.51,-1.26 2.7,-2.89 3.43,-4.75 -1.73,-4.39 -6,-7.5 -11,-7.5 -1.4,0 -2.74,0.25 -3.98,0.7l2.16,2.16C10.74,7.13 11.35,7 12,7zM2,4.27l2.28,2.28 0.46,0.46C3.08,8.3 1.78,10.02 1,12c1.73,4.39 6,7.5 11,7.5 1.55,0 3.03,-0.3 4.38,-0.84l0.42,0.42L19.73,22 21,20.73 3.27,3 2,4.27zM7.53,9.8l1.55,1.55c-0.05,0.21 -0.08,0.43 -0.08,0.65 0,1.66 1.34,3 3,3 0.22,0 0.44,-0.03 0.65,-0.08l1.55,1.55c-0.67,0.33 -1.41,0.53 -2.2,0.53 -2.76,0 -5,-2.24 -5,-5 0,-0.79 0.2,-1.53 0.53,-2.2zM11.84,9.02l3.15,3.15 0.02,-0.16c0,-1.66 -1.34,-3 -3,-3l-0.17,0.01z"/>
+
+</vector>

forge-gui-android/src/com/badlogic/gdx/backends/android/AndroidApplication.java

@@ -31,18 +31,18 @@ import android.view.Window;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 import com.badlogic.gdx.*;
-/*import com.badlogic.gdx.backends.android.keyboardheight.AndroidRKeyboardHeightProvider;
+import com.badlogic.gdx.backends.android.keyboardheight.AndroidRKeyboardHeightProvider;
 import com.badlogic.gdx.backends.android.keyboardheight.KeyboardHeightProvider;
-import com.badlogic.gdx.backends.android.keyboardheight.StandardKeyboardHeightProvider;*/
+import com.badlogic.gdx.backends.android.keyboardheight.StandardKeyboardHeightProvider;
 import com.badlogic.gdx.backends.android.surfaceview.FillResolutionStrategy;
 import com.badlogic.gdx.utils.*;
 
-/** A modified implementation of the {@link Application} interface for Android - Forge app. Create an {@link Activity} that derives from this class.
+/** An implementation of the {@link Application} interface for Android. Create an {@link Activity} that derives from this class.
  * In the {@link Activity#onCreate(Bundle)} method call the {@link #initialize(ApplicationListener)} method specifying the
  * configuration for the GLSurfaceView.
  *
  * @author mzechner */
-public class ForgeAndroidApplication extends Activity implements AndroidApplicationBase {
+public class AndroidApplication extends Activity implements AndroidApplicationBase {
 
 	protected AndroidGraphics graphics;
 	protected AndroidInput input;
@@ -56,14 +56,14 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 	protected final Array<Runnable> runnables = new Array<Runnable>();
 	protected final Array<Runnable> executedRunnables = new Array<Runnable>();
 	protected final SnapshotArray<LifecycleListener> lifecycleListeners = new SnapshotArray<LifecycleListener>(
-		LifecycleListener.class);
+			LifecycleListener.class);
 	private final Array<AndroidEventListener> androidEventListeners = new Array<AndroidEventListener>();
 	protected int logLevel = LOG_INFO;
 	protected ApplicationLogger applicationLogger;
 	protected boolean useImmersiveMode = false;
 	private int wasFocusChanged = -1;
 	private boolean isWaitingForAudio = false;
-	//private KeyboardHeightProvider keyboardHeightProvider;
+	private KeyboardHeightProvider keyboardHeightProvider;
 
 	protected boolean renderUnderCutout = false;
 
@@ -121,7 +121,7 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 		config.nativeLoader.load();
 		setApplicationLogger(new AndroidApplicationLogger());
 		graphics = new AndroidGraphics(this, config,
-			config.resolutionStrategy == null ? new FillResolutionStrategy() : config.resolutionStrategy);
+				config.resolutionStrategy == null ? new FillResolutionStrategy() : config.resolutionStrategy);
 		input = createInput(this, this, graphics.view, config);
 		audio = createAudio(this, config);
 		files = createFiles();
@@ -171,26 +171,26 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 
 		createWakeLock(config.useWakelock);
 		useImmersiveMode(this.useImmersiveMode);
-		/*if (this.useImmersiveMode) {
+		if (this.useImmersiveMode) {
 			AndroidVisibilityListener vlistener = new AndroidVisibilityListener();
 			vlistener.createListener(this);
-		}*/
+		}
 
 		// detect an already connected bluetooth keyboardAvailable
 		if (getResources().getConfiguration().keyboard != Configuration.KEYBOARD_NOKEYS) input.setKeyboardAvailable(true);
 
 		setLayoutInDisplayCutoutMode(this.renderUnderCutout);
 
-		/*if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
 			keyboardHeightProvider = new AndroidRKeyboardHeightProvider(this);
 		} else {
 			keyboardHeightProvider = new StandardKeyboardHeightProvider(this);
-		}*/
+		}
 	}
 
 	protected FrameLayout.LayoutParams createLayoutParams () {
 		FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(android.view.ViewGroup.LayoutParams.MATCH_PARENT,
-			android.view.ViewGroup.LayoutParams.MATCH_PARENT);
+				android.view.ViewGroup.LayoutParams.MATCH_PARENT);
 		layoutParams.gravity = Gravity.CENTER;
 		return layoutParams;
 	}
@@ -226,13 +226,13 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 
 	@Override
 	public void useImmersiveMode (boolean use) {
-		/*if (!use) return;
+		if (!use) return;
 
 		View view = getWindow().getDecorView();
 		int code = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
 				| View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN
 				| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
-		view.setSystemUiVisibility(code);*/
+		view.setSystemUiVisibility(code);
 	}
 
 	@Override
@@ -260,7 +260,7 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 		graphics.onPauseGLSurfaceView();
 
 		super.onPause();
-		//keyboardHeightProvider.setKeyboardHeightObserver(null);
+		keyboardHeightProvider.setKeyboardHeightObserver(null);
 	}
 
 	@Override
@@ -289,19 +289,19 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 			this.isWaitingForAudio = false;
 		}
 		super.onResume();
-		/*keyboardHeightProvider.setKeyboardHeightObserver((DefaultAndroidInput)Gdx.input);
+		keyboardHeightProvider.setKeyboardHeightObserver((DefaultAndroidInput)Gdx.input);
 		((AndroidGraphics)getGraphics()).getView().post(new Runnable() {
 			@Override
 			public void run () {
 				keyboardHeightProvider.start();
 			}
-		});*/
+		});
 	}
 
 	@Override
 	protected void onDestroy () {
 		super.onDestroy();
-		//keyboardHeightProvider.close();
+		keyboardHeightProvider.close();
 	}
 
 	@Override
@@ -385,7 +385,7 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 		handler.post(new Runnable() {
 			@Override
 			public void run () {
-				ForgeAndroidApplication.this.finish();
+				AndroidApplication.this.finish();
 			}
 		});
 	}
@@ -528,7 +528,7 @@ public class ForgeAndroidApplication extends Activity implements AndroidApplicat
 		return new DefaultAndroidFiles(this.getAssets(), this, true);
 	}
 
-	/*public KeyboardHeightProvider getKeyboardHeightProvider () {
+	public KeyboardHeightProvider getKeyboardHeightProvider () {
 		return keyboardHeightProvider;
-	}*/
+	}
 }

forge-gui-android/src/com/badlogic/gdx/backends/android/surfaceview/GLSurfaceView20.java

@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2009 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.
+ */
+
+package com.badlogic.gdx.backends.android.surfaceview;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.opengl.GLSurfaceView;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import com.badlogic.gdx.Input.OnscreenKeyboardType;
+import com.badlogic.gdx.backends.android.DefaultAndroidInput;
+
+/** A simple GLSurfaceView sub-class that demonstrates how to perform OpenGL ES 2.0 rendering into a GL Surface. Note the
+ * following important details:
+ * <p/>
+ * - The class must use a custom context factory to enable 2.0 rendering. See ContextFactory class definition below.
+ * <p/>
+ * - The class must use a custom EGLConfigChooser to be able to select an EGLConfig that supports 2.0. This is done by providing a
+ * config specification to eglChooseConfig() that has the attribute EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT
+ * flag set. See ConfigChooser class definition below.
+ * <p/>
+ * - The class must select the surface's format, then choose an EGLConfig that matches it exactly (with regards to
+ * red/green/blue/alpha channels bit depths). Failure to do so would result in an EGL_BAD_MATCH error. */
+public class GLSurfaceView20 extends GLSurfaceView {
+    static String TAG = "GL2JNIView";
+    private static final boolean DEBUG = false;
+
+    final ResolutionStrategy resolutionStrategy;
+    static int targetGLESVersion;
+    public OnscreenKeyboardType onscreenKeyboardType = OnscreenKeyboardType.Default;
+
+    public GLSurfaceView20 (Context context, ResolutionStrategy resolutionStrategy, int targetGLESVersion) {
+        super(context);
+        GLSurfaceView20.targetGLESVersion = targetGLESVersion;
+        this.resolutionStrategy = resolutionStrategy;
+        init(false, 16, 0);
+    }
+
+    public GLSurfaceView20 (Context context, ResolutionStrategy resolutionStrategy) {
+        this(context, resolutionStrategy, 2);
+    }
+
+    public GLSurfaceView20 (Context context, boolean translucent, int depth, int stencil, ResolutionStrategy resolutionStrategy) {
+        super(context);
+        this.resolutionStrategy = resolutionStrategy;
+        init(translucent, depth, stencil);
+
+    }
+
+    @Override
+    protected void onMeasure (int widthMeasureSpec, int heightMeasureSpec) {
+        ResolutionStrategy.MeasuredDimension measures = resolutionStrategy.calcMeasures(widthMeasureSpec, heightMeasureSpec);
+        setMeasuredDimension(measures.width, measures.height);
+    }
+
+    @Override
+    public InputConnection onCreateInputConnection (EditorInfo outAttrs) {
+
+        // add this line, the IME can show the selectable words when use chinese input method editor.
+        if (outAttrs != null) {
+            outAttrs.imeOptions = outAttrs.imeOptions | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
+            outAttrs.inputType = DefaultAndroidInput.getAndroidInputType(onscreenKeyboardType, true);
+        }
+
+        BaseInputConnection connection = new BaseInputConnection(this, false) {
+            @Override
+            public boolean deleteSurroundingText (int beforeLength, int afterLength) {
+                /*
+                 * In Jelly Bean, they don't send key events for delete. Instead, they send beforeLength = 1, afterLength = 0. So,
+                 * we'll just simulate what it used to do.
+                 */
+                if (beforeLength == 1 && afterLength == 0) {
+                    sendDownUpKeyEventForBackwardCompatibility(KeyEvent.KEYCODE_DEL);
+                    return true;
+                }
+                return super.deleteSurroundingText(beforeLength, afterLength);
+            }
+
+            private void sendDownUpKeyEventForBackwardCompatibility (final int code) {
+                final long eventTime = SystemClock.uptimeMillis();
+                super.sendKeyEvent(new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, code, 0, 0,
+                        KeyCharacterMap.VIRTUAL_KEYBOARD, 0, KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE));
+                super.sendKeyEvent(new KeyEvent(SystemClock.uptimeMillis(), eventTime, KeyEvent.ACTION_UP, code, 0, 0,
+                        KeyCharacterMap.VIRTUAL_KEYBOARD, 0, KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE));
+            }
+        };
+        return connection;
+    }
+
+    @Override
+    public void onDetachedFromWindow () {
+        super.onDetachedFromWindow();
+    }
+
+    private void init (boolean translucent, int depth, int stencil) {
+
+        /*
+         * By default, GLSurfaceView() creates a RGB_888 opaque surface. If we want a translucent one, we should change the
+         * surface's format here, using PixelFormat.TRANSLUCENT for GL Surfaces is interpreted as any 32-bit surface with alpha by
+         * SurfaceFlinger.
+         */
+        if (translucent) {
+            this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
+        }
+
+        /*
+         * Setup the context factory for 2.0 rendering. See ContextFactory class definition below
+         */
+        setEGLContextFactory(new ContextFactory());
+
+        /*
+         * We need to choose an EGLConfig that matches the format of our surface exactly. This is going to be done in our custom
+         * config chooser. See ConfigChooser class definition below.
+         */
+        setEGLConfigChooser(
+                translucent ? new ConfigChooser(8, 8, 8, 8, depth, stencil) : new ConfigChooser(8, 8, 8, 0, depth, stencil));
+
+        /* Set the renderer responsible for frame rendering */
+    }
+
+    static class ContextFactory implements GLSurfaceView.EGLContextFactory {
+        private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+
+        public EGLContext createContext (EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
+            Log.w(TAG, "creating OpenGL ES " + GLSurfaceView20.targetGLESVersion + ".0 context");
+            checkEglError("Before eglCreateContext " + targetGLESVersion, egl);
+            int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, GLSurfaceView20.targetGLESVersion, EGL10.EGL_NONE};
+            EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
+            boolean success = checkEglError("After eglCreateContext " + targetGLESVersion, egl);
+
+            if ((!success || context == null) && GLSurfaceView20.targetGLESVersion > 2) {
+                Log.w(TAG, "Falling back to GLES 2");
+                GLSurfaceView20.targetGLESVersion = 2;
+                return createContext(egl, display, eglConfig);
+            }
+            Log.w(TAG, "Returning a GLES " + targetGLESVersion + " context");
+            return context;
+        }
+
+        public void destroyContext (EGL10 egl, EGLDisplay display, EGLContext context) {
+            egl.eglDestroyContext(display, context);
+        }
+    }
+
+    static boolean checkEglError (String prompt, EGL10 egl) {
+        int error;
+        boolean result = true;
+        while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
+            result = false;
+            Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
+        }
+        return result;
+    }
+
+    private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
+
+        public ConfigChooser (int r, int g, int b, int a, int depth, int stencil) {
+            mRedSize = r;
+            mGreenSize = g;
+            mBlueSize = b;
+            mAlphaSize = a;
+            mDepthSize = depth;
+            mStencilSize = stencil;
+        }
+
+        /*
+         * This EGL config specification is used to specify 2.0 rendering. We use a minimum size of 4 bits for red/green/blue, but
+         * will perform actual matching in chooseConfig() below.
+         */
+        private static int EGL_OPENGL_ES2_BIT = 4;
+        private static int[] s_configAttribs2 = {EGL10.EGL_RED_SIZE, 4, EGL10.EGL_GREEN_SIZE, 4, EGL10.EGL_BLUE_SIZE, 4,
+                EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_NONE};
+
+        public EGLConfig chooseConfig (EGL10 egl, EGLDisplay display) {
+
+            /*
+             * Get the number of minimally matching EGL configurations
+             */
+            int[] num_config = new int[1];
+            egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
+
+            int numConfigs = num_config[0];
+
+            if (numConfigs <= 0) {
+                throw new IllegalArgumentException("No configs match configSpec");
+            }
+
+            /*
+             * Allocate then read the array of minimally matching EGL configs
+             */
+            EGLConfig[] configs = new EGLConfig[numConfigs];
+            egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
+
+            if (DEBUG) {
+                printConfigs(egl, display, configs);
+            }
+            /*
+             * Now return the "best" one
+             */
+            return chooseConfig(egl, display, configs);
+        }
+
+        public EGLConfig chooseConfig (EGL10 egl, EGLDisplay display, EGLConfig[] configs) {
+            for (EGLConfig config : configs) {
+                int d = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
+                int s = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
+
+                // We need at least mDepthSize and mStencilSize bits
+                if (d < mDepthSize || s < mStencilSize) continue;
+
+                // We want an *exact* match for red/green/blue/alpha
+                int r = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
+                int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
+                int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
+                int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
+
+                if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize) return config;
+            }
+            return null;
+        }
+
+        private int findConfigAttrib (EGL10 egl, EGLDisplay display, EGLConfig config, int attribute, int defaultValue) {
+
+            if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+                return mValue[0];
+            }
+            return defaultValue;
+        }
+
+        private void printConfigs (EGL10 egl, EGLDisplay display, EGLConfig[] configs) {
+            int numConfigs = configs.length;
+            Log.w(TAG, String.format("%d configurations", numConfigs));
+            for (int i = 0; i < numConfigs; i++) {
+                Log.w(TAG, String.format("Configuration %d:\n", i));
+                printConfig(egl, display, configs[i]);
+            }
+        }
+
+        private void printConfig (EGL10 egl, EGLDisplay display, EGLConfig config) {
+            int[] attributes = {EGL10.EGL_BUFFER_SIZE, EGL10.EGL_ALPHA_SIZE, EGL10.EGL_BLUE_SIZE, EGL10.EGL_GREEN_SIZE,
+                    EGL10.EGL_RED_SIZE, EGL10.EGL_DEPTH_SIZE, EGL10.EGL_STENCIL_SIZE, EGL10.EGL_CONFIG_CAVEAT, EGL10.EGL_CONFIG_ID,
+                    EGL10.EGL_LEVEL, EGL10.EGL_MAX_PBUFFER_HEIGHT, EGL10.EGL_MAX_PBUFFER_PIXELS, EGL10.EGL_MAX_PBUFFER_WIDTH,
+                    EGL10.EGL_NATIVE_RENDERABLE, EGL10.EGL_NATIVE_VISUAL_ID, EGL10.EGL_NATIVE_VISUAL_TYPE, 0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
+                    EGL10.EGL_SAMPLES, EGL10.EGL_SAMPLE_BUFFERS, EGL10.EGL_SURFACE_TYPE, EGL10.EGL_TRANSPARENT_TYPE,
+                    EGL10.EGL_TRANSPARENT_RED_VALUE, EGL10.EGL_TRANSPARENT_GREEN_VALUE, EGL10.EGL_TRANSPARENT_BLUE_VALUE, 0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
+                    0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
+                    0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
+                    0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
+                    EGL10.EGL_LUMINANCE_SIZE, EGL10.EGL_ALPHA_MASK_SIZE, EGL10.EGL_COLOR_BUFFER_TYPE, EGL10.EGL_RENDERABLE_TYPE, 0x3042 // EGL10.EGL_CONFORMANT
+            };
+            String[] names = {"EGL_BUFFER_SIZE", "EGL_ALPHA_SIZE", "EGL_BLUE_SIZE", "EGL_GREEN_SIZE", "EGL_RED_SIZE",
+                    "EGL_DEPTH_SIZE", "EGL_STENCIL_SIZE", "EGL_CONFIG_CAVEAT", "EGL_CONFIG_ID", "EGL_LEVEL", "EGL_MAX_PBUFFER_HEIGHT",
+                    "EGL_MAX_PBUFFER_PIXELS", "EGL_MAX_PBUFFER_WIDTH", "EGL_NATIVE_RENDERABLE", "EGL_NATIVE_VISUAL_ID",
+                    "EGL_NATIVE_VISUAL_TYPE", "EGL_PRESERVED_RESOURCES", "EGL_SAMPLES", "EGL_SAMPLE_BUFFERS", "EGL_SURFACE_TYPE",
+                    "EGL_TRANSPARENT_TYPE", "EGL_TRANSPARENT_RED_VALUE", "EGL_TRANSPARENT_GREEN_VALUE", "EGL_TRANSPARENT_BLUE_VALUE",
+                    "EGL_BIND_TO_TEXTURE_RGB", "EGL_BIND_TO_TEXTURE_RGBA", "EGL_MIN_SWAP_INTERVAL", "EGL_MAX_SWAP_INTERVAL",
+                    "EGL_LUMINANCE_SIZE", "EGL_ALPHA_MASK_SIZE", "EGL_COLOR_BUFFER_TYPE", "EGL_RENDERABLE_TYPE", "EGL_CONFORMANT"};
+            int[] value = new int[1];
+            for (int i = 0; i < attributes.length; i++) {
+                int attribute = attributes[i];
+                String name = names[i];
+                if (egl.eglGetConfigAttrib(display, config, attribute, value)) {
+                    Log.w(TAG, String.format("  %s: %d\n", name, value[0]));
+                } else {
+                    // Log.w(TAG, String.format(" %s: failed\n", name));
+                    while (egl.eglGetError() != EGL10.EGL_SUCCESS)
+                        ;
+                }
+            }
+        }
+
+        // Subclasses can adjust these values:
+        protected int mRedSize;
+        protected int mGreenSize;
+        protected int mBlueSize;
+        protected int mAlphaSize;
+        protected int mDepthSize;
+        protected int mStencilSize;
+        private int[] mValue = new int[1];
+    }
+}

forge-gui-android/src/forge/app/Main.java

@@ -51,7 +51,7 @@ import android.widget.TableRow;
 import android.widget.TextView;
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Version;
-import com.badlogic.gdx.backends.android.ForgeAndroidApplication;
+import com.badlogic.gdx.backends.android.AndroidApplication;
 import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;
 import com.badlogic.gdx.backends.android.AndroidAudio;
 import com.badlogic.gdx.backends.android.AsynchronousAndroidAudio;
@@ -73,7 +73,7 @@ import java.text.Normalizer;
 import java.util.ArrayList;
 import java.util.Date;
 
-public class Main extends ForgeAndroidApplication {
+public class Main extends AndroidApplication {
     private AndroidAdapter Gadapter;
     private ArrayList<String> gamepads;
     private AndroidClipboard androidClipboard;

forge-gui/src/main/java/forge/util/ImageFetcher.java

@@ -105,6 +105,8 @@ public abstract class ImageFetcher {
             setupObserver(destFile.getAbsolutePath(), callback, downloadUrls);
             return;
         }
+        if (imageKey.equalsIgnoreCase("t:null"))
+            return;
 
         boolean useArtCrop = "Crop".equals(FModel.getPreferences().getPref(ForgePreferences.FPref.UI_CARD_ART_FORMAT));
         final String prefix = imageKey.substring(0, 2);
@@ -195,14 +197,10 @@ public abstract class ImageFetcher {
                     for (PaperCard pc : clones) {
                         if (clones.size() > 1) {//clones only
                             if (!paperCard.getEdition().equalsIgnoreCase(pc.getEdition())) {
-                                StringBuilder set = new StringBuilder(ForgeConstants.URL_PIC_DOWNLOAD);
+                                downloadUrls.add(ForgeConstants.URL_PIC_DOWNLOAD + ImageUtil.getDownloadUrl(pc, face));
-                                set.append(ImageUtil.getDownloadUrl(pc, face));
-                                downloadUrls.add(set.toString());
                             }
                         } else {// original from set
-                            StringBuilder set = new StringBuilder(ForgeConstants.URL_PIC_DOWNLOAD);
+                            downloadUrls.add(ForgeConstants.URL_PIC_DOWNLOAD + ImageUtil.getDownloadUrl(pc, face));
-                            set.append(ImageUtil.getDownloadUrl(pc, face));
-                            downloadUrls.add(set.toString());
                         }
                     }
                 }
@@ -228,6 +226,8 @@ public abstract class ImageFetcher {
                     CardEdition E = StaticData.instance().getEditions().get(tempdata[1]);
                     if (E != null && E.getType() == CardEdition.Type.CUSTOM_SET) return; //Custom set token, skip fetching.
                 }
+                if (filename.equalsIgnoreCase("null.jpg"))
+                    return;
                 System.err.println("No specified file for '" + filename + "'.. Attempting to download from default Url");
                 tokenUrl = String.format("%s%s", ForgeConstants.URL_TOKEN_DOWNLOAD, filename);
             }