My App crashes when i try to run it on my phone.

Common bugs/problems with the Android SDK the Emulator and the ADT-Plugin.

My App crashes when i try to run it on my phone.

Postby fkopew » Mon Aug 13, 2012 10:21 am

My app crashes when i try to run it on my phone.The app uses opengl.
Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. import android.app.Activity;
  2. //import android.app.ActivityManager;
  3. ///import android.content.Context;
  4. //import android.content.pm.ConfigurationInfo;
  5. import android.opengl.GLSurfaceView;
  6. import android.os.Bundle;
  7.  
  8. public class ThesphereActivity extends Activity {
  9.     /** Called when the activity is first created. */
  10.         private GLSurfaceView mGLSurfaceView;
  11.     @Override
  12.     public void onCreate(Bundle savedInstanceState) {
  13.         super.onCreate(savedInstanceState);
  14.        
  15.         mGLSurfaceView = new GLSurfaceView(this);
  16.      
  17.         // Check if the system supports OpenGL ES 2.0.
  18.     //    final ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
  19.       //  final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
  20.         final boolean supportsEs2 =true;
  21.      
  22.         if (supportsEs2)
  23.         {
  24.             // Request an OpenGL ES 2.0 compatible context.
  25.             mGLSurfaceView.setEGLContextClientVersion(2);
  26.      
  27.             // Set the renderer to our demo renderer, defined below.
  28.             mGLSurfaceView.setRenderer(new LessonOneRenderer());
  29.         }
  30.         else
  31.         {
  32.             // This is where you could create an OpenGL ES 1.x compatible
  33.             // renderer if you wanted to support both ES 1 and ES 2.
  34.             return;
  35.         }
  36.      
  37.         setContentView(mGLSurfaceView);
  38.        
  39.     }
  40.         @Override
  41.         protected void onPause() {
  42.        
  43.                 super.onPause();
  44.                 mGLSurfaceView.onPause();
  45.         }
  46.         @Override
  47.         protected void onResume() {
  48.                 super.onResume();
  49.                 mGLSurfaceView.onResume();
  50.  
  51.         }
  52.    
  53.    
  54. }
Parsed in 0.035 seconds, using GeSHi 1.0.8.4

Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. import java.nio.ByteBuffer;
  2. import java.nio.ByteOrder;
  3. import java.nio.FloatBuffer;
  4.  
  5. import javax.microedition.khronos.egl.EGLConfig;
  6. import javax.microedition.khronos.opengles.GL10;
  7.  
  8. import android.opengl.GLES20;
  9. import android.opengl.GLSurfaceView;
  10. import android.opengl.Matrix;
  11. import android.os.SystemClock;
  12.  
  13. /**
  14.  * This class implements our custom renderer. Note that the GL10 parameter passed in is unused for OpenGL ES 2.0
  15.  * renderers -- the static class GLES20 is used instead.
  16.  */
  17. public class LessonOneRenderer implements GLSurfaceView.Renderer
  18. {
  19.         /**
  20.          * Store the model matrix. This matrix is used to move models from object space (where each model can be thought
  21.          * of being located at the center of the universe) to world space.
  22.          */
  23.         private float[] mModelMatrix = new float[16];
  24.  
  25.         /**
  26.          * Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space;
  27.          * it positions things relative to our eye.
  28.          */
  29.         private float[] mViewMatrix = new float[16];
  30.  
  31.         /** Store the projection matrix. This is used to project the scene onto a 2D viewport. */
  32.         private float[] mProjectionMatrix = new float[16];
  33.  
  34.         /** Allocate storage for the final combined matrix. This will be passed into the shader program. */
  35.         private float[] mMVPMatrix = new float[16];
  36.  
  37.         /** Store our model data in a float buffer. */
  38.         private final FloatBuffer mTriangle1Vertices;
  39.         private final FloatBuffer mTriangle2Vertices;
  40.         private final FloatBuffer mTriangle3Vertices;
  41.  
  42.         /** This will be used to pass in the transformation matrix. */
  43.         private int mMVPMatrixHandle;
  44.  
  45.         /** This will be used to pass in model position information. */
  46.         private int mPositionHandle;
  47.  
  48.         /** This will be used to pass in model color information. */
  49.         private int mColorHandle;
  50.  
  51.         /** How many bytes per float. */
  52.         private final int mBytesPerFloat = 4;
  53.  
  54.         /** How many elements per vertex. */
  55.         private final int mStrideBytes = 7 * mBytesPerFloat;   
  56.  
  57.         /** Offset of the position data. */
  58.         private final int mPositionOffset = 0;
  59.  
  60.         /** Size of the position data in elements. */
  61.         private final int mPositionDataSize = 3;
  62.  
  63.         /** Offset of the color data. */
  64.         private final int mColorOffset = 3;
  65.  
  66.         /** Size of the color data in elements. */
  67.         private final int mColorDataSize = 4;          
  68.  
  69.         /**
  70.          * Initialize the model data.
  71.          */
  72.         public LessonOneRenderer()
  73.         {      
  74.                 // Define points for equilateral triangles.
  75.  
  76.                 // This triangle is red, green, and blue.
  77.                 final float[] triangle1VerticesData = {
  78.                                 // X, Y, Z,
  79.                                 // R, G, B, A
  80.                     -0.5f, -0.25f, 0.0f,
  81.                     1.0f, 0.0f, 0.0f, 1.0f,
  82.  
  83.                     0.5f, -0.25f, 0.0f,
  84.                     0.0f, 0.0f, 1.0f, 1.0f,
  85.  
  86.                     0.0f, 0.559016994f, 0.0f,
  87.                     0.0f, 1.0f, 0.0f, 1.0f};
  88.  
  89.                 // This triangle is yellow, cyan, and magenta.
  90.                 final float[] triangle2VerticesData = {
  91.                                 // X, Y, Z,
  92.                                 // R, G, B, A
  93.                     -0.5f, -0.25f, 0.0f,
  94.                     1.0f, 1.0f, 0.0f, 1.0f,
  95.  
  96.                     0.5f, -0.25f, 0.0f,
  97.                     0.0f, 1.0f, 1.0f, 1.0f,
  98.  
  99.                     0.0f, 0.559016994f, 0.0f,
  100.                     1.0f, 0.0f, 1.0f, 1.0f};
  101.  
  102.                 // This triangle is white, gray, and black.
  103.                 final float[] triangle3VerticesData = {
  104.                                 // X, Y, Z,
  105.                                 // R, G, B, A
  106.                     -0.5f, -0.25f, 0.0f,
  107.                     1.0f, 1.0f, 1.0f, 1.0f,
  108.  
  109.                     0.5f, -0.25f, 0.0f,
  110.                     0.5f, 0.5f, 0.5f, 1.0f,
  111.  
  112.                     0.0f, 0.559016994f, 0.0f,
  113.                     0.0f, 0.0f, 0.0f, 1.0f};
  114.  
  115.                 // Initialize the buffers.
  116.                 mTriangle1Vertices = ByteBuffer.allocateDirect(triangle1VerticesData.length * mBytesPerFloat)
  117.         .order(ByteOrder.nativeOrder()).asFloatBuffer();
  118.                 mTriangle2Vertices = ByteBuffer.allocateDirect(triangle2VerticesData.length * mBytesPerFloat)
  119.         .order(ByteOrder.nativeOrder()).asFloatBuffer();
  120.                 mTriangle3Vertices = ByteBuffer.allocateDirect(triangle3VerticesData.length * mBytesPerFloat)
  121.         .order(ByteOrder.nativeOrder()).asFloatBuffer();
  122.  
  123.                 mTriangle1Vertices.put(triangle1VerticesData).position(0);
  124.                 mTriangle2Vertices.put(triangle2VerticesData).position(0);
  125.                 mTriangle3Vertices.put(triangle3VerticesData).position(0);
  126.         }
  127.  
  128.  
  129.         public void onSurfaceCreated(GL10 glUnused, EGLConfig config)
  130.         {
  131.                 // Set the background clear color to gray.
  132.                 GLES20.glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
  133.  
  134.                 // Position the eye behind the origin.
  135.                 final float eyeX = 0.0f;
  136.                 final float eyeY = 0.0f;
  137.                 final float eyeZ = 1.5f;
  138.  
  139.                 // We are looking toward the distance
  140.                 final float lookX = 0.0f;
  141.                 final float lookY = 0.0f;
  142.                 final float lookZ = -5.0f;
  143.  
  144.                 // Set our up vector. This is where our head would be pointing were we holding the camera.
  145.                 final float upX = 0.0f;
  146.                 final float upY = 1.0f;
  147.                 final float upZ = 0.0f;
  148.  
  149.                 // Set the view matrix. This matrix can be said to represent the camera position.
  150.                 // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
  151.                 // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
  152.                 Matrix.setLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
  153.  
  154.                 final String vertexShader =
  155.                         "uniform mat4 u_MVPMatrix;      \n"             // A constant representing the combined model/view/projection matrix.
  156.  
  157.                   + "attribute vec4 a_Position;     \n"         // Per-vertex position information we will pass in.
  158.                   + "attribute vec4 a_Color;        \n"         // Per-vertex color information we will pass in.                         
  159.  
  160.                   + "varying vec4 v_Color;          \n"         // This will be passed into the fragment shader.
  161.  
  162.                   + "void main()                    \n"         // The entry point for our vertex shader.
  163.                   + "{                              \n"
  164.                   + "   v_Color = a_Color;          \n"         // Pass the color through to the fragment shader.
  165.                                                                                                         // It will be interpolated across the triangle.
  166.                   + "   gl_Position = u_MVPMatrix   \n"         // gl_Position is a special variable used to store the final position.
  167.                   + "               * a_Position;   \n"     // Multiply the vertex by the matrix to get the final point in                                                                                       
  168.                   + "}                              \n";    // normalized screen coordinates.
  169.  
  170.                 final String fragmentShader =
  171.                         "precision mediump float;       \n"             // Set the default precision to medium. We don't need as high of a
  172.                                                                                                         // precision in the fragment shader.                           
  173.                   + "varying vec4 v_Color;          \n"         // This is the color from the vertex shader interpolated across the
  174.                                                                                                         // triangle per fragment.                        
  175.                   + "void main()                    \n"         // The entry point for our fragment shader.
  176.                   + "{                              \n"
  177.                   + "   gl_FragColor = v_Color;     \n"         // Pass the color directly through the pipeline.                 
  178.                   + "}                              \n";                                                                                               
  179.  
  180.                 // Load in the vertex shader.
  181.                 int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
  182.  
  183.                 if (vertexShaderHandle != 0)
  184.                 {
  185.                         // Pass in the shader source.
  186.                         GLES20.glShaderSource(vertexShaderHandle, vertexShader);
  187.  
  188.                         // Compile the shader.
  189.                         GLES20.glCompileShader(vertexShaderHandle);
  190.  
  191.                         // Get the compilation status.
  192.                         final int[] compileStatus = new int[1];
  193.                         GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
  194.  
  195.                         // If the compilation failed, delete the shader.
  196.                         if (compileStatus[0] == 0)
  197.                         {                              
  198.                                 GLES20.glDeleteShader(vertexShaderHandle);
  199.                                 vertexShaderHandle = 0;
  200.                         }
  201.                 }
  202.  
  203.                 if (vertexShaderHandle == 0)
  204.                 {
  205.                         throw new RuntimeException("Error creating vertex shader.");
  206.                 }
  207.  
  208.                 // Load in the fragment shader shader.
  209.                 int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
  210.  
  211.                 if (fragmentShaderHandle != 0)
  212.                 {
  213.                         // Pass in the shader source.
  214.                         GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);
  215.  
  216.                         // Compile the shader.
  217.                         GLES20.glCompileShader(fragmentShaderHandle);
  218.  
  219.                         // Get the compilation status.
  220.                         final int[] compileStatus = new int[1];
  221.                         GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
  222.  
  223.                         // If the compilation failed, delete the shader.
  224.                         if (compileStatus[0] == 0)
  225.                         {                              
  226.                                 GLES20.glDeleteShader(fragmentShaderHandle);
  227.                                 fragmentShaderHandle = 0;
  228.                         }
  229.                 }
  230.  
  231.                 if (fragmentShaderHandle == 0)
  232.                 {
  233.                         throw new RuntimeException("Error creating fragment shader.");
  234.                 }
  235.  
  236.                 // Create a program object and store the handle to it.
  237.                 int programHandle = GLES20.glCreateProgram();
  238.  
  239.                 if (programHandle != 0)
  240.                 {
  241.                         // Bind the vertex shader to the program.
  242.                         GLES20.glAttachShader(programHandle, vertexShaderHandle);                      
  243.  
  244.                         // Bind the fragment shader to the program.
  245.                         GLES20.glAttachShader(programHandle, fragmentShaderHandle);
  246.  
  247.                         // Bind attributes
  248.                         GLES20.glBindAttribLocation(programHandle, 0, "a_Position");
  249.                         GLES20.glBindAttribLocation(programHandle, 1, "a_Color");
  250.  
  251.                         // Link the two shaders together into a program.
  252.                         GLES20.glLinkProgram(programHandle);
  253.  
  254.                         // Get the link status.
  255.                         final int[] linkStatus = new int[1];
  256.                         GLES20.glGetProgramiv(programHandle, GLES20.GL_LINK_STATUS, linkStatus, 0);
  257.  
  258.                         // If the link failed, delete the program.
  259.                         if (linkStatus[0] == 0)
  260.                         {                              
  261.                                 GLES20.glDeleteProgram(programHandle);
  262.                                 programHandle = 0;
  263.                         }
  264.                 }
  265.  
  266.                 if (programHandle == 0)
  267.                 {
  268.                         throw new RuntimeException("Error creating program.");
  269.                 }
  270.        
  271.         // Set program handles. These will later be used to pass in values to the program.
  272.         mMVPMatrixHandle = GLES20.glGetUniformLocation(programHandle, "u_MVPMatrix");        
  273.         mPositionHandle = GLES20.glGetAttribLocation(programHandle, "a_Position");
  274.         mColorHandle = GLES20.glGetAttribLocation(programHandle, "a_Color");        
  275.        
  276.         // Tell OpenGL to use this program when rendering.
  277.         GLES20.glUseProgram(programHandle);        
  278.         }      
  279.  
  280.        
  281.         public void onSurfaceChanged(GL10 glUnused, int width, int height)
  282.         {
  283.                 // Set the OpenGL viewport to the same size as the surface.
  284.                 GLES20.glViewport(0, 0, width, height);
  285.  
  286.                 // Create a new perspective projection matrix. The height will stay the same
  287.                 // while the width will vary as per aspect ratio.
  288.                 final float ratio = (float) width / height;
  289.                 final float left = -ratio;
  290.                 final float right = ratio;
  291.                 final float bottom = -1.0f;
  292.                 final float top = 1.0f;
  293.                 final float near = 1.0f;
  294.                 final float far = 10.0f;
  295.  
  296.                 Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);
  297.         }      
  298.  
  299.  
  300.         public void onDrawFrame(GL10 glUnused)
  301.         {
  302.                 GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);                               
  303.                
  304.         // Do a complete rotation every 10 seconds.
  305.         long time = SystemClock.uptimeMillis() % 10000L;
  306.         float angleInDegrees = (360.0f / 10000.0f) * ((int) time);
  307.        
  308.         // Draw the triangle facing straight on.
  309.         Matrix.setIdentityM(mModelMatrix, 0);
  310.         Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);        
  311.         drawTriangle(mTriangle1Vertices);
  312.        
  313.         // Draw one translated a bit down and rotated to be flat on the ground.
  314.         Matrix.setIdentityM(mModelMatrix, 0);
  315.         Matrix.translateM(mModelMatrix, 0, 0.0f, -1.0f, 0.0f);
  316.         Matrix.rotateM(mModelMatrix, 0, 90.0f, 1.0f, 0.0f, 0.0f);
  317.         Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);        
  318.         drawTriangle(mTriangle2Vertices);
  319.        
  320.         // Draw one translated a bit to the right and rotated to be facing to the left.
  321.         Matrix.setIdentityM(mModelMatrix, 0);
  322.         Matrix.translateM(mModelMatrix, 0, 1.0f, 0.0f, 0.0f);
  323.         Matrix.rotateM(mModelMatrix, 0, 90.0f, 0.0f, 1.0f, 0.0f);
  324.         Matrix.rotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);
  325.         drawTriangle(mTriangle3Vertices);
  326.         }      
  327.  
  328.         /**
  329.          * Draws a triangle from the given vertex data.
  330.          *
  331.          * @param aTriangleBuffer The buffer containing the vertex data.
  332.          */
  333.         private void drawTriangle(final FloatBuffer aTriangleBuffer)
  334.         {              
  335.                 // Pass in the position information
  336.                 aTriangleBuffer.position(mPositionOffset);
  337.         GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false,
  338.                         mStrideBytes, aTriangleBuffer);        
  339.                
  340.         GLES20.glEnableVertexAttribArray(mPositionHandle);        
  341.        
  342.         // Pass in the color information
  343.         aTriangleBuffer.position(mColorOffset);
  344.         GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false,
  345.                         mStrideBytes, aTriangleBuffer);        
  346.        
  347.         GLES20.glEnableVertexAttribArray(mColorHandle);
  348.        
  349.                 // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
  350.         // (which currently contains model * view).
  351.         Matrix.multiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
  352.        
  353.         // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
  354.         // (which now contains model * view * projection).
  355.         Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
  356.  
  357.         GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
  358.         GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);                              
  359.         }
  360. }"]
Parsed in 0.075 seconds, using GeSHi 1.0.8.4
fkopew
Freshman
Freshman
 
Posts: 3
Joined: Mon Aug 13, 2012 10:17 am

Top

Return to SDK/ADT/Emulator Problems

Who is online

Users browsing this forum: No registered users and 5 guests