Determining Max/Min Texture Size Limit in Android OpenGLES
===

I've been assigned to create an open source Java port of this [Objective C GPUImage Framework][1] so that it can be used in an Android application.  I am to recreate it as closely as I can, with all the variable names, function names, etc all the same.  I'm in the beginning stages and I'm trying to port GPUImageOpenGLESContext.h and GPUImageOpenGLESContext.m (Sorry, would provide links, but as a new users I cannot add any more links).

I'm having difficulty with these methods

    + (GLint)maximumTextureSizeForThisDevice;
    {
        GLint maxTextureSize; 
        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
        return maxTextureSize;
    }
    
    + (GLint)maximumTextureUnitsForThisDevice;
    {
        GLint maxTextureUnits; 
        glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
        return maxTextureUnits;
    }

It seems that in Objective C, you can just simply call these methods but in Java you cannot.  I've done some searching and found that most people said to use a GLSurfaceView, but that would require an activity, correct?  I was very excited when I found this [Get Maximum OpenGL ES 2.0 Texture Size Limit on Android][2], but the response claims that the code would not work.

**So, my question is, how can I get the minimum and maximum texture in a class that is not an activity? Using GLSurfaceView?**

I'd also appreciate any suggestions on how to port this over.  I've never ported anything from Objective C to Java, so any advice would be appreciated!

If it would be helpful, here is my current code:

    public class GPUImageOpenGLESContext 
    {
    	private static GPUImageOpenGLESContext instance = null;
    	
    	EGLContext context;
    	
    	protected GPUImageOpenGLESContext()
    	{
    		// This is a protected empty method
    		// that exists only to prevent
    		// this singleton object from
    		// multiple instantiation
    		
    		return;
    	}
    	
    	public enum GPUImageRotationMode { 
    			kGPUImageNoRotation, kGPUImageRotateLeft, kGPUImageRotateRight, kGPUImageFlipVertical,
    			kGPUImageFlipHorizontal, kGPUImageRotateRightFlipVertical, kGPUImageRotate180
    	}
    
    	public GPUImageRotationMode GPUImageRotationSwapsWidthAndHeight(GPUImageRotationMode rotation)
    	{
    		// TODO: Implement GPUImageRotationSwapsWidthAndHeight macro as method
    		//rotation = ((rotation) == kGPUImageRotateLeft || (rotation) == kGPUImageRotateRight || (rotation) == kGPUImageRotateRightFlipVertical)
    		return rotation;
    	}
    	
    	public static GPUImageOpenGLESContext sharedImageProcessingOpenGLESContext()
    	{
    		if (instance == null)
    		{
    			instance = new GPUImageOpenGLESContext();
    		}
    		return instance;
    	}
    	
    	public static void useImageProcessingContext()
    	{
    		 EGLContext imageProcessingContext = GPUImageOpenGLESContext.sharedImageProcessingOpenGLESContext().context;
    		 if (EGLContext.getEGL() != imageProcessingContext)
    		 {
    			 // In Objective C, this call would be here:
    			 // [EAGLContext setCurrentContext:imageProcessingContext]
    			 
    			 // Cannot figure out how to handle this.  For now, throws an exception.
    			 throw new RuntimeException("useImageProcessingContext not equal to EGLContext");
    		 }
    		 
    		 return;
    	}
    	
    	public static int maximumTextureSizeForThisDevice()
    	{
    		int[] maxTextureSize = new int[1];
    		
    		// TODO: See if you can use gl. without an activity
    		//GL10 gl = new GL10();
    		//EGL gl = EGLContext.getEGL();
    		
    		//gl.glGetIntegerv(GL10.GL_MAX_TEXTURE_SIZE, maxTextureSize, 0);
    		
    		return maxTextureSize[0];
    	}
    	
    	public static int maximumTextureUnitsForThisDevice()
    	{
    		// TODO: Implement maximumTextureUnitsForThisDevice();
    		return -1;
    	}
    	
    	public static CGSize sizeThatFitsWithinATextureForSize(CGSize inputSize)
    	{
    		int maxTextureSize = maximumTextureSizeForThisDevice();
    		
    		if ((inputSize.width < maxTextureSize) && (inputSize.height < maxTextureSize))
    		{
    			return inputSize;
    		}
    		
    		CGSize adjustedSize = new CGSize();
    		if (inputSize.width > inputSize.height)
    		{
    			adjustedSize.width = (float)maxTextureSize;
    			adjustedSize.height = ((float)maxTextureSize / inputSize.width) * inputSize.height;
    		}
    		else
    		{
    			adjustedSize.height = (float)maxTextureSize;
    			adjustedSize.width = ((float)maxTextureSize / inputSize.height) * inputSize.width;
    		}
    		
    		return adjustedSize;
    	}
    	
    	public EGLContext getContext()
    	{
    		if (context == null)
    		{
    			// TODO: Implement getContext()
    		}
    	}
    	
    	public interface GPUImageInput
    	{
    		public void newFrameReadyAtTime(Time frameTime);
    		public void setInputTextureAtIndex(int newInputTexture, int textureIndex);
    		public int nextAvailableTextureIndex();
    		public void setInputSizeAtIndex(CGSize newSize, int textureIndex);
    		public void setInputRotationAtIndex(GPUImageRotationMode newInputRotation, int textureIndex);
    		public CGSize maximumOutputSize();
    		public void endProcessing();
    		public boolean shouldIgnoreUpdatesToThisTarget();
    	}
    }

  [1]: https://github.com/BradLarson/GPUImage
  [2]: http://stackoverflow.com/questions/11022109/get-maximum-opengl-es-2-0-texture-size-limit-in-android