Android 5.0/6.0无法运行应用求助（compileSdkVersion 26）

Hey there, let's work through this compatibility problem together. Your project's minSdkVersion 21 should absolutely support Android 5.0 (API 21) and 6.0 (API 23), so the issue is likely tied to specific code or configuration details that aren't handling older API levels properly. Here's how to diagnose and fix this:

First: Get Clear Crash Details from Logcat #

You mentioned you can't make sense of Logcat—let's narrow it down to the critical bits:

• Filter Logcat by Error level, and look for logs starting with AndroidRuntime (these are crash reports).
• Focus on the Caused by: section of the stack trace—this is almost always the root cause of the crash. Copy that full stack trace and share it if you can; it'll make debugging way faster.

Potential Issues in Your SurfaceView Code #

Looking at your Juego class snippet, here are common pitfalls that break on older Android versions:

1. Drawable Initialization Compatibility #

If you're initializing Drawables using getResources().getDrawable(), this method was deprecated in API 22 and requires a Theme parameter on API 21-22 (it throws an exception without it). On API 23+, the no-theme version works, but it'll crash on 5.0/6.0.

Fix this by using AppCompatResources (from the AndroidX AppCompat library) to handle compatibility automatically:

// Replace this:
Drawable myDrawable = getResources().getDrawable(R.drawable.your_drawable);
// With this:
Drawable myDrawable = AppCompatResources.getDrawable(getContext(), R.drawable.your_drawable);

2. SurfaceView Thread Safety #

SurfaceViews require proper handling of the SurfaceHolder lifecycle. If you're initializing personaje or starting drawing before the surfaceCreated() callback fires, older Android versions might throw errors because the Surface isn't ready yet.

Make sure your code follows this pattern:

public class Juego extends SurfaceView implements SurfaceHolder.Callback {
    Personaje personaje;
    Paint paint;
    private DrawingThread drawingThread;

    public Juego(Context context, AttributeSet attrs) {
        super(context, attrs);
        paint = new Paint();
        getHolder().addCallback(this); // Register lifecycle callback
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // Initialize your character and start drawing ONLY when the surface is ready
        personaje = new Personaje();
        drawingThread = new DrawingThread(holder, this);
        drawingThread.setRunning(true);
        drawingThread.start();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // Stop the drawing thread safely to avoid leaks/crashes
        boolean retry = true;
        while (retry) {
            try {
                drawingThread.setRunning(false);
                drawingThread.join();
                retry = false;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // ... rest of your drawing logic ...
}

Project Configuration Checks #

1. Java 8 Desugaring #

If you're using Java 8 features (like lambdas, streams, or Optional), older Android versions (API <24) don't support them natively. You need to enable core library desugaring in your build.gradle (Module level):

android {
    compileOptions {
        coreLibraryDesugaringEnabled true
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4' // Use the latest version
}

2. Third-Party Library Compatibility #

Some third-party libraries might have hidden dependencies on API 24+ features, even if their docs say they support API 21. Use Android Studio's lint tool to check for this:

• Go to Analyze > Inspect Code
• In the inspection profile, select Compatibility Checks > Android Lint > New API Usage
• Run the inspection—this will flag any code (including in libraries) that uses APIs higher than your minSdkVersion without proper compatibility handling.

3. Dynamic Permissions (Android 6.0+) #

Android 6.0 (API 23) introduced runtime permissions. If your app uses "dangerous" permissions (like WRITE_EXTERNAL_STORAGE, CAMERA, etc.), you need to request them at runtime—otherwise, the app will crash when trying to access those features.

Add permission request logic to your activity:

// Check if permission is granted
if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
        != PackageManager.PERMISSION_GRANTED) {
    // Request permission
    ActivityCompat.requestPermissions(this,
            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
            PERMISSION_REQUEST_CODE);
}

Next Steps #

1. Grab the full Caused by: stack trace from Logcat on a crashing Android 5.0/6.0 device.
2. Check your Drawable initialization and SurfaceView lifecycle code against the tips above.
3. Run the Android Lint inspection to catch hidden API compatibility issues.

Once you have that stack trace, we can pinpoint the exact problem!

内容的提问来源于stack exchange，提问作者Zekirak