StrictMode pour les versions de plate-forme inférieure

Question

J'ai commencé à utiliser l'Android et StrictMode constater que ce serait génial de l'avoir toujours en cours d'exécution au cours du développement et non pas seulement sur une branche spéciale que j'ai créé dans git. La raison pour laquelle je l'ai fait mon besoin d'applications pour fonctionner avec 1.6.

J'ai lu sur le blog des développeurs Android que vous pouvez le configurer de sorte que vous activez via la réflexion. Je me demandais comment cela effectivement ressembler et s'il pourrait être possible d'avoir cette documentée ici (ou ailleurs) plutôt que d'avoir tout le monde qui veut l'utiliser travaillent eux-mêmes.

Answer 1

Je ne voulais pas attendre et a décidé de faire l'effort et mettre en œuvre moi-même. Il se résume essentiellement à envelopper dans une classe StrictMode d'emballage et de décider lors de l'exécution par réflexion si nous pouvons l'activer.

Je l'ai documenté en détail dans un blog poster et a rendu disponible en github .

Answer 2

J'ai lu le blog de Manfred, mais il ne fonctionne pas si vous définissez version plate-forme cible inférieure à 2,3 parce que la méthode de StrictMode.enableDefaults(); est indisponible.

Voici ma solution qui repose entièrement sur la réflexion et ne génère pas d'erreurs de compilation:

    try {
        Class<?> strictModeClass = Class.forName("android.os.StrictMode", true, Thread.currentThread()
                .getContextClassLoader());

        Class<?> threadPolicyClass = Class.forName("android.os.StrictMode$ThreadPolicy", true, Thread
                .currentThread().getContextClassLoader());

        Class<?> threadPolicyBuilderClass = Class.forName("android.os.StrictMode$ThreadPolicy$Builder", true,
                Thread.currentThread().getContextClassLoader());

        Method setThreadPolicyMethod = strictModeClass.getMethod("setThreadPolicy", threadPolicyClass);

        Method detectAllMethod = threadPolicyBuilderClass.getMethod("detectAll");
        Method penaltyMethod = threadPolicyBuilderClass.getMethod("penaltyLog");
        Method buildMethod = threadPolicyBuilderClass.getMethod("build");

        Constructor<?> threadPolicyBuilderConstructor = threadPolicyBuilderClass.getConstructor();
        Object threadPolicyBuilderObject = threadPolicyBuilderConstructor.newInstance();

        Object obj = detectAllMethod.invoke(threadPolicyBuilderObject);

        obj = penaltyMethod.invoke(obj);
        Object threadPolicyObject = buildMethod.invoke(obj);
        setThreadPolicyMethod.invoke(strictModeClass, threadPolicyObject);

    } catch (Exception ex) {
        Log.w(TAG, ex);
    }

Answer 3

J'ai vu votre billet de blog. Puisque vous ne voulez jamais StrictMode de configuration au plus une fois par fichier Java, serait-il logique de simplifier le code pour appeler pour la configuration comme suit?

Voici un autre StrictModeWrapper:

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.StrictMode;

public class StrictModeWrapper {
    public static void init(Context context) {
        // check if android:debuggable is set to true
        int applicationFlags = context.getApplicationInfo().flags;
        if ((applicationFlags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                .detectDiskReads()
                .detectDiskWrites()
                .detectNetwork()
                .penaltyLog()
                .build());
            StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                .detectLeakedSqlLiteObjects()
                .penaltyLog()
                .penaltyDeath()
                .build());
        }
    }
}

A partir de votre code, il vous suffit de faire ce qui suit:

try {
    StrictModeWrapper.init(this);
}
catch(Throwable throwable) {
    Log.v("StrictMode", "... is not available. Punting...");
}

où cette est le contexte local, comme votre activité ou application ou autre. Cela semble fonctionner pour le pré-Android 2.3, et vous donne aussi le pouvoir d'utiliser les autres méthodes des classes Builder pour configurer exactement StrictMode que vous le souhaitez.

Answer 4

Je suis une autre variante jeté ensemble sur le thème ci-dessus, que je l'ai indiqué dans un billet de blog ici . La principale différence dans mon approche est qu'elle fournit également des emballages pour les objets de stratégie de disque et de vm, de sorte que vous pouvez facilement le code entre crochets StrictMode-offenser les changements politiques temporaires. Vos commentaires sont les bienvenus.

Answer 5

Pour code Pixel J'ai également ajouté ce (basé sur Android StrictMode Exemple d'API):

            // VM policy
            Class<?> VmPolicyClass = Class.forName("android.os.StrictMode$VmPolicy", true, Thread.currentThread().getContextClassLoader());

            Class<?> VmPolicyBuilderClass = Class.forName("android.os.StrictMode$VmPolicy$Builder", true, Thread.currentThread().getContextClassLoader());

            Method setVmPolicyMethod = strictModeClass.getMethod("setVmPolicy", VmPolicyClass);

            Method detectLeakedSqlLiteObjectsMethod = VmPolicyBuilderClass.getMethod("detectLeakedSqlLiteObjects");
            Method detectLeakedClosableObjectsMethod = null; 
            try
            {
                detectLeakedClosableObjectsMethod = VmPolicyBuilderClass.getMethod("detectLeakedClosableObjects");
            }
            catch (Exception e) {}
            Method penaltyLogMethod = VmPolicyBuilderClass.getMethod("penaltyLog");
            Method penaltyDeathMethod = VmPolicyBuilderClass.getMethod("penaltyDeath");
            Method VmbuildMethod = VmPolicyBuilderClass.getMethod("build");

            Constructor<?> VmPolicyBuilderConstructor = VmPolicyBuilderClass.getConstructor();
            Object VmPolicyBuilderObject = VmPolicyBuilderConstructor.newInstance();

            Object Vmobj = detectLeakedSqlLiteObjectsMethod.invoke(VmPolicyBuilderObject);
            if (detectLeakedClosableObjectsMethod != null) Vmobj = detectLeakedClosableObjectsMethod.invoke(Vmobj);
            Vmobj = penaltyLogMethod.invoke(Vmobj);
            Vmobj = penaltyDeathMethod.invoke(Vmobj);

            Object VmPolicyObject = VmbuildMethod.invoke(Vmobj);
            setVmPolicyMethod.invoke(strictModeClass, VmPolicyObject);

Answer 6

Définir le Manifest Android à quelque chose comme ça.

< uses-sdk android:minSdkVersion="8" android:targetSdkVersion="16" android:maxSdkVersion="16"/ >

utiliser le code ci-dessous dans onCreate Method.

int SDK_INT = android.os.Build.VERSION.SDK_INT;

} if (SDK_INT>8){

StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();

StrictMode.setThreadPolicy(policy);

}

Remarque:. Désactiver l'avertissement que vous vérifiez déjà la version de l'Android va utiliser ce code

Ce code sera activé si la version Android est supérieure à Android 2.2