StrictMode per le versioni piattaforma inferiore

Question

Ho iniziato a utilizzare lo StrictMode Android e scoprire che sarebbe bello averlo sempre in esecuzione durante lo sviluppo e non solo su un ramo speciale che ho creato in git. La ragione per cui ho fatto questo è il mio requisito applicazioni per correre con 1.6 e superiori.

ho letto sul blog degli sviluppatori di Android che è possibile impostarlo in modo che lo si attiva attraverso la riflessione. Mi stavo chiedendo come sarebbe in realtà simile e se potrebbe essere possibile avere qui documentato (o da qualche altra parte), piuttosto che avere a tutti che vuole usarlo lavorare fuori se stessi.

Answer 1

Quindi non voleva aspettare e ha deciso di fare lo sforzo e mettere in atto questo me stesso. Si riduce sostanzialmente verso il basso per avvolgere StrictMode in una classe wrapper e decidere in fase di esecuzione attraverso la riflessione, se siamo in grado di attivarlo.

ho documentato in dettaglio in un blog postare e reso disponibile in github .

Answer 2

ho letto post sul blog di Manfred ma non funziona se si imposta obiettivo versione della piattaforma inferiore a 2.3 perché il metodo StrictMode.enableDefaults(); non è disponibile.

Ecco la mia soluzione che si basa completamente sulla riflessione e non genera errori di compilazione:

    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

Ho visto il tuo post sul blog. Dal momento che sempre e solo desidera impostare StrictMode al massimo una volta per ogni file Java, sarebbe alcun senso per semplificare il codice per chiamare per l'installazione come segue?

Ecco uno StrictModeWrapper alternativo:

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());
        }
    }
}

dal codice, avete solo bisogno di fare quanto segue:

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

dove questo è il contesto locale, come il tuo Attività o Application o qualsiasi altra cosa. Questo sembra funzionare per il pre-2.3 di Android, e anche ti dà il potere di utilizzare altri metodi delle classi Builder per configurare StrictMode esattamente come vuoi.

Answer 4

Ho gettato insieme un'altra variazione sul tema di cui sopra, che ho descritto in un post sul blog qui . La principale differenza nel mio approccio è che fornisce anche i wrapper per gli oggetti del disco e la politica vm, in modo che sia facilmente possibile racchiudere il codice StrictMode-offendere con i cambiamenti politici temporanei. Il feedback è benvenuto.

Answer 5

Codice a Pixel ho aggiunto anche questo (sulla base di StrictMode Android esempio 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

Imposta il Manifesto Android per qualcosa di simile.

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

utilizzare il sottostante Codice nel metodo onCreate.

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);

}

. Nota: disattivare l'avviso, come si sta già verificando la versione di Android sta per utilizzare questo codice

questo codice verrà attivato se la versione di Android è superiore a Android 2.2