编译时生成自定义错误，强制Activity必设ScreenId以保障安全检查

Absolutely! You can enforce valid screenId implementation at compile time using a few different approaches, depending on your tech stack (Java/Kotlin) and flexibility needs. Here are the most reliable solutions to stop those missing/empty screenId issues for good:

方案一：自定义Lint规则（Android专属，推荐） #

Android's built-in Lint tool is perfect for this—it gives real-time IDE feedback and blocks builds if rules are violated. Here's how to set it up:

Step 1: Create a Lint module #

First, add a new Java/Kotlin module to your project (name it something like lint-rules) and configure its build.gradle for Lint development.

Step 2: Write the detector #

This detector will scan all classes extending your BaseActivity and check for valid screenId implementations:

public class ScreenIdDetector extends Detector implements Detector.UastScanner {

    public static final Issue ISSUE_MISSING_SCREEN_ID = Issue.create(
            "MissingValidScreenId",
            "Activity must implement a non-empty screenId",
            "All activities extending BaseActivity must override `getScreenId()` and return a valid non-empty string for tracking purposes.",
            Category.CORRECTNESS,
            10, // Priority
            Severity.ERROR, // Makes this a build-blocking error
            new Implementation(ScreenIdDetector.class, Scope.JAVA_FILE_SCOPE)
    );

    @Override
    public List<Class<? extends UElement>> getApplicableUastTypes() {
        return Collections.singletonList(UClass.class);
    }

    @Override
    public void visitClass(JavaContext context, UClass node) {
        PsiClass psiClass = node.getPsi();
        // Skip if this isn't a subclass of BaseActivity
        if (!isSubclassOf(psiClass, "com.yourpackage.BaseActivity")) return;

        // Check if getScreenId is implemented correctly
        boolean hasValidScreenId = false;
        for (PsiMethod method : psiClass.getMethods()) {
            if ("getScreenId".equals(method.getName()) && method.getReturnType() != null 
                && method.getReturnType().equalsToText("java.lang.String")) {
                
                // Check if the method returns a non-empty value
                UReturnStatement returnStmt = getReturnStatement(method);
                if (returnStmt != null) {
                    UExpression returnExpr = returnStmt.getReturnValue();
                    if (returnExpr instanceof ULiteralExpression) {
                        Object value = ((ULiteralExpression) returnExpr).getValue();
                        if (value != null && !((String) value).isEmpty()) {
                            hasValidScreenId = true;
                            break;
                        }
                    } else {
                        // Allow dynamic values (like enums or constants), but warn to verify
                        context.report(ISSUE_MISSING_SCREEN_ID, method, context.getLocation(method),
                                "Verify screenId returns a non-empty value");
                        hasValidScreenId = true;
                        break;
                    }
                }
            }
        }

        if (!hasValidScreenId) {
            context.report(ISSUE_MISSING_SCREEN_ID, node, context.getLocation(node),
                    "Activity must override `getScreenId()` and return a non-empty string");
        }
    }

    private boolean isSubclassOf(PsiClass psiClass, String superClassName) {
        if (psiClass == null) return false;
        if (superClassName.equals(psiClass.getQualifiedName())) return true;
        return isSubclassOf(psiClass.getSuperClass(), superClassName);
    }

    private UReturnStatement getReturnStatement(PsiMethod method) {
        // Extract the return statement from the method body
        UMethod uMethod = UastContextKt.toUElement(method);
        if (uMethod == null || uMethod.getBody() == null) return null;
        return uMethod.getBody().getStatements().stream()
                .filter(s -> s instanceof UReturnStatement)
                .map(s -> (UReturnStatement) s)
                .findFirst()
                .orElse(null);
    }
}

Step 3: Register the detector #

Create a registry class to expose your Lint rule:

public class ScreenIdLintRegistry extends LintRegistry {
    @Override
    public List<Issue> getIssues() {
        return Collections.singletonList(ScreenIdDetector.ISSUE_MISSING_SCREEN_ID);
    }
}

Step 4: Enable build blocking #

In your app module's build.gradle, make sure Lint aborts on errors:

android {
    lintOptions {
        abortOnError true
    }
}

Now, any activity missing getScreenId() or returning an empty value will trigger a compile error, and developers will see warnings/errors directly in Android Studio.

方案二：编译时注解处理器（跨平台，Java/Kotlin） #

If you need a solution that works outside Android (or want more control), use an annotation processor to validate code during compilation:

Step 1: Define an annotation #

Mark activities that require a screenId:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface RequiresScreenId {
}

Step 2: Write the processor #

This processor scans annotated classes and checks for valid getScreenId() implementations:

@SupportedAnnotationTypes("com.yourpackage.RequiresScreenId")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class ScreenIdProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(RequiresScreenId.class)) {
            if (element.getKind() != ElementKind.CLASS) continue;
            TypeElement activityClass = (TypeElement) element;

            // Check if getScreenId is implemented
            boolean hasValidImpl = false;
            for (Element enclosed : activityClass.getEnclosedElements()) {
                if (enclosed.getKind() == ElementKind.METHOD 
                    && enclosed.getSimpleName().contentEquals("getScreenId")) {
                    
                    ExecutableElement method = (ExecutableElement) enclosed;
                    // Validate return type and value
                    if (method.getReturnType().getKind() == TypeKind.STRING) {
                        // Use AST analysis to check return value (simplified example)
                        try {
                            Trees trees = Trees.instance(processingEnv);
                            TreePath path = trees.getPath(element, enclosed);
                            MethodTree methodTree = (MethodTree) path.getLeaf();
                            ReturnTree returnStmt = methodTree.getBody().getStatements().stream()
                                    .filter(s -> s.getKind() == Tree.Kind.RETURN)
                                    .map(s -> (ReturnTree) s)
                                    .findFirst()
                                    .orElse(null);

                            if (returnStmt == null) {
                                reportError(activityClass, "getScreenId() must return a value");
                            } else if (returnStmt.getExpression().getKind() == Tree.Kind.LITERAL) {
                                LiteralTree literal = (LiteralTree) returnStmt.getExpression();
                                if (literal.getValue() == null || ((String) literal.getValue()).isEmpty()) {
                                    reportError(activityClass, "screenId cannot be empty");
                                } else {
                                    hasValidImpl = true;
                                }
                            } else {
                                // Allow dynamic values, but warn
                                processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING,
                                        "Verify screenId returns a non-empty value", activityClass);
                                hasValidImpl = true;
                            }
                        } catch (Exception e) {
                            reportError(activityClass, "Failed to validate screenId: " + e.getMessage());
                        }
                    }
                }
            }

            if (!hasValidImpl) {
                reportError(activityClass, "Must override getScreenId() with a non-empty string");
            }
        }
        return true;
    }

    private void reportError(TypeElement element, String message) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, message, element);
    }
}

Step 3: Register the processor #

Create a file resources/META-INF/services/javax.annotation.processing.Processor with:

com.yourpackage.ScreenIdProcessor

Now, any activity annotated with @RequiresScreenId (or you can modify the processor to scan all BaseActivity subclasses) will be validated at compile time, with errors blocking the build.

方案三：Kotlin抽象属性 + 枚举（最简单，Kotlin-only） #

If you're using Kotlin, leverage the language's type system to enforce implementation:

// Define valid screen IDs as an enum for guaranteed validity
enum class ScreenId(val value: String) {
    HOME("home_screen"),
    PROFILE("profile_screen"),
    SETTINGS("settings_screen")
}

abstract class BaseActivity : AppCompatActivity() {
    // Force subclasses to provide a ScreenId
    abstract val screenId: ScreenId
}

// Subclasses must implement screenId, or the compiler throws an error
class HomeActivity : BaseActivity() {
    override val screenId = ScreenId.HOME
}

This approach is zero-boilerplate and gives compile-time enforcement out of the box. If you need dynamic screen IDs, replace the enum with a String abstract property—Kotlin will still force subclasses to implement it.

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