Utilisation du Gestionnaire Android

http://developer.android.com/reference/android/os/Handler.html

package : android.os
public class
Handler
extends Object

Est un Gestionnaire qui vous permet d'envoyer et de traiter le Message et Praticable objets associés à un thread MessageQueue. Chaque instance de Gestionnaire est associé à un fil et ce fil de message de la file d'attente. Lorsque vous créez un nouveau Gestionnaire, il est lié à l'thread /message de la file d'attente du thread qui est de la création -- à partir de ce moment, il va livrer des messages et runnables pour que la file d'attente de messages et de les exécuter comme ils sortent de la file d'attente de messages.

Il y a deux utilisations principales pour un Gestionnaire de:

1. à l'annexe messages et runnables pour être exécuté comme un point
   dans l'avenir; et
2. à mettre en file d'attente d'une action à effectuer sur un autre thread que
   votre propre.

Exemple 1

utilisation de gestionnaire en application de page d'accueil.

if (!isFirstIn) {
    mHandler.sendEmptyMessageDelayed(GO_HOME, SPLASH_DELAY_MILLIS);
} else {
    mHandler.sendEmptyMessageDelayed(GO_GUIDE, SPLASH_DELAY_MILLIS);
} 


/**************************************************************************************
*1. Handler
*/
private Handler mHandler = new Handler() {
    public void handleMessage(Message msg) {
        if(isAuto){
            switch (msg.what) {
            case GO_HOME:
                goHome();
                break;
            case GO_GUIDE:
                goGuide();
                break;
            }
        }
        super.handleMessage(msg);
    }
}; 
private void goHome() {
    Intent intent = new Intent(SplashActivity.this, MainAct.class);
    SplashActivity.this.startActivity(intent);
    SplashActivity.this.finish();
} 

private void goGuide() {
    Intent intent = new Intent(SplashActivity.this, GuideActivity.class);
    SplashActivity.this.startActivity(intent);
    SplashActivity.this.finish();
} 

Exemple 2

utilisation du Gestionnaire de réseau de demandes de l'enfant dans le thread si la demande de travail peut prend du temps.

new Thread(new Runnable(){
    @Override
    public void run() {
        String versionPath = Parameters.getCheckVersionPath();
        String result = RequestHelper.doGet(versionPath, null);
        Message msg = new Message();
        Bundle data = new Bundle();
        data.putString("result",result);
        msg.setData(data);
        handler1.sendMessage(msg);
    }
}).start();

handler1 = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        String result = msg.getData().getString("result");
        JSONObject obj;
        try {
            obj = new JSONObject(result);
            Map<String, String> versionInfo = Helper.getSoftwareVersion(obj);
            if (versionInfo != null) {
                newVersion = versionInfo.get("version");
                updateUrl = versionInfo.get("url");
            }
        } catch (JSONException e) {
            Log.w("net work error!", e);
        }
    }

}; 

Exemple 3

utilisation du Gestionnaire et de la Minuterie pour mettre à jour la barre de progression.

logobar = (ImageView) findViewById(R.id.splash_bar);//progress bar.
logobarClipe = (ClipDrawable) logobar.getBackground();

timer = new Timer();
timer.schedule(new TimerTask() {
    public void run() {
        updateLogoBarHandler.sendEmptyMessage(0);
}}, 0, rate);


/**************************************************************************************
*2. Handler
*/
//update progress bar.
private Handler updateLogoBarHandler = new Handler() {
    public void handleMessage(Message msg) {
        if(logobarClipe.getLevel() < 10000){
            //1.update image.
            logobarClipe.setLevel(logobarClipe.getLevel() + rate*2);  

            //2.update text.
            float percent = logobarClipe.getLevel() /100;
            String percentTxtVerbose = String.valueOf(percent);
            String percentTxt = percentTxtVerbose.substring(0, percentTxtVerbose.indexOf('.')) + "%";
            bartxt.setText(percentTxt);

        }else{
            timer.cancel();
        }  
        super.handleMessage(msg);
    }
}; 

OriginalL'auteur Eddy

Il y a un danger dans l'utilisation anonyme des classes dans Android. Comme décrit dans ce blog -

En Java, non statique interne et anonyme des classes de tenir un implicite
référence à leur extérieur de la classe.

Et ici est une occasion pour une fuite.

Donc, la réponse courte est: mettre en œuvre les méthodes d'interface ou d'utiliser des classes internes (qui ne tiennent pas l'extérieur de la classe de référence).

Par exemple, une fuite sûr Gestionnaire pourrait ressembler à ceci:

private static class ChangeTextHandler extends Handler {
    private final WeakReference activity;

    public ChangeTextHandler(MainActivity activity) {
        this.activity = new WeakReference<>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        MainActivity activity = this.activity.get();
        if (activity == null) {
            Log.e(TAG, "Activity is null ChangeTextHandler.handleMessage()!");
            return;
        }

        final String text = (String) msg.getData().get(BUNDLE_KEY);
        if (!TextUtils.isEmpty(text)) {
            switch (msg.what) {
                //do something
            }
        }
    }
}

J'ai fait un blog autour de l'utilisation de Gestionnaires d', donc peut-être la peine de vérifier 🙂

OriginalL'auteur lomza