other posting benim üzerinde hafif bir varyasyon

Temelde bir mesaj diyaloglar görevden veya gösterilen neden bir sürü mesaj aldığında* *3 Handler var.

App arka planda olduğunda onPause ama sonra hala mesajlarımı tahmin edileceği gibi geliyor. Parçaları kullanıyorum, çünkü ancak, sadece kapatmak ve o IllegalStateException sonuçlanacak gibi diyaloglar gösteremem.

Sadece devlet veya kaybı sağlayan kapatmak iptal edemem.

Handler ben de için önerilen bir yaklaşım olup olmadığını merak ediyorum nasıl bir duraklatılmış ise iletileri işlemek gerekir.

Düşünüyorum olası bir çözüm iletileri ve duraklatılmış oynarken geliyor geri onResume bir kayıt. Bu biraz yetersiz olduğunu ve bu çerçeve daha zarif bir şekilde işlemek için bir şey olması gerektiğini düşünüyorum.

Şimdiden teşekkürler. Peter.

Android işletim sistemini yeterince sorunu gideren bir mekanizma var gibi görünmüyor, ancak bu model geçici çözüm uygulamak için nispeten basit bir sağlar inanıyorum.

Aşağıdaki sınıf android etrafında sarıcı.os.Bir etkinlik olduğunda mesaj tamponlar kadar işleyicisi durakladı ve devam onları geri oynar.

Parça bir devlet (örneğin, taahhüt, kapatmak) sadece işleyicisi mesaj olarak adlandırılan herhangi bir kod sağlamak.

PauseHandler sınıfından amirin türetmek.

Etkinlik bir onPause aldığı zaman() Ara PauseHandler.() duraklama ve onResume() çağrısı PauseHandler.() özgeçmiş.

Handler handleMessage uygulamanızı Replace() processMessage().

StoreMessage basit bir uygulama() sağlamak her zaman true verir.

/**
 * Message Handler class that supports buffering up of messages when the
 * activity is paused i.e. in the background.
 */
public abstract class PauseHandler extends Handler {

    /**
     * Message Queue Buffer
     */
    final Vector<Message> messageQueueBuffer = new Vector<Message>();

    /**
     * Flag indicating the pause state
     */
    private boolean paused;

    /**
     * Resume the handler
     */
    final public void resume() {
        paused = false;

        while (messageQueueBuffer.size() > 0) {
            final Message msg = messageQueueBuffer.elementAt(0);
            messageQueueBuffer.removeElementAt(0);
            sendMessage(msg);
        }
    }

    /**
     * Pause the handler
     */
    final public void pause() {
        paused = true;
    }

    /**
     * Notification that the message is about to be stored as the activity is
     * paused. If not handled the message will be saved and replayed when the
     * activity resumes.
     * 
     * @param message
     *            the message which optional can be handled
     * @return true if the message is to be stored
     */
    protected abstract boolean storeMessage(Message message);

    /**
     * Notification message to be processed. This will either be directly from
     * handleMessage or played back from a saved message when the activity was
     * paused.
     * 
     * @param message
     *            the message to be handled
     */
    protected abstract void processMessage(Message message);

    /** {@inheritDoc} */
    @Override
    final public void handleMessage(Message msg) {
        if (paused) {
            if (storeMessage(msg)) {
                Message msgCopy = new Message();
                msgCopy.copyFrom(msg);
                messageQueueBuffer.add(msgCopy);
            }
        } else {
            processMessage(msg);
        }
    }
}

Aşağıda PausedHandler sınıfın nasıl kullanılacağına dair basit bir örnek.

Bir düğmeye tıklayın gecikmiş bir ileti işleyicisi için gönderilir.

Bu ileti işleyicisi (UI thread) aldığında bir DialogFragment görüntüler.

Eğer PausedHandler sınıfı kullanılan bir İllegalStateException eğer ev düğmesine iletişim başlatmak için test tuşuna bastıktan sonra basılı gösterilecek.

public class FragmentTestActivity extends Activity {

    /**
     * Used for "what" parameter to handler messages
     */
    final static int MSG_WHAT = ('F' << 16)   ('T' << 8)   'A';
    final static int MSG_SHOW_DIALOG = 1;

    int value = 1;

    final static class State extends Fragment {

        static final String TAG = "State";
        /**
         * Handler for this activity
         */
        public ConcreteTestHandler handler = new ConcreteTestHandler();

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setRetainInstance(true);            
        }

        @Override
        public void onResume() {
            super.onResume();

            handler.setActivity(getActivity());
            handler.resume();
        }

        @Override
        public void onPause() {
            super.onPause();

            handler.pause();
        }

        public void onDestroy() {
            super.onDestroy();
            handler.setActivity(null);
        }
    }

    /**
     * 2 second delay
     */
    final static int DELAY = 2000;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        if (savedInstanceState == null) {
            final Fragment state = new State();
            final FragmentManager fm = getFragmentManager();
            final FragmentTransaction ft = fm.beginTransaction();
            ft.add(state, State.TAG);
            ft.commit();
        }

        final Button button = (Button) findViewById(R.id.popup);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                final FragmentManager fm = getFragmentManager();
                State fragment = (State) fm.findFragmentByTag(State.TAG);
                if (fragment != null) {
                    // Send a message with a delay onto the message looper
                    fragment.handler.sendMessageDelayed(
                            fragment.handler.obtainMessage(MSG_WHAT, MSG_SHOW_DIALOG, value  ),
                            DELAY);
                }
            }
        });
    }

    public void onSaveInstanceState(Bundle bundle) {
        super.onSaveInstanceState(bundle);
    }

    /**
     * Simple test dialog fragment
     */
    public static class TestDialog extends DialogFragment {

        int value;

        /**
         * Fragment Tag
         */
        final static String TAG = "TestDialog";

        public TestDialog() {
        }

        public TestDialog(int value) {
            this.value = value;
        }

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            final View inflatedView = inflater.inflate(R.layout.dialog, container, false);
            TextView text = (TextView) inflatedView.findViewById(R.id.count);
            text.setText(getString(R.string.count, value));
            return inflatedView;
        }
    }

    /**
     * Message Handler class that supports buffering up of messages when the
     * activity is paused i.e. in the background.
     */
    static class ConcreteTestHandler extends PauseHandler {

        /**
         * Activity instance
         */
        protected Activity activity;

        /**
         * Set the activity associated with the handler
         * 
         * @param activity
         *            the activity to set
         */
        final void setActivity(Activity activity) {
            this.activity = activity;
        }

        @Override
        final protected boolean storeMessage(Message message) {
            // All messages are stored by default
            return true;
        };

        @Override
        final protected void processMessage(Message msg) {

            final Activity activity = this.activity;
            if (activity != null) {
                switch (msg.what) {

                case MSG_WHAT:
                    switch (msg.arg1) {
                    case MSG_SHOW_DIALOG:
                        final FragmentManager fm = activity.getFragmentManager();
                        final TestDialog dialog = new TestDialog(msg.arg2);

                        // We are on the UI thread so display the dialog
                        // fragment
                        dialog.show(fm, TestDialog.TAG);
                        break;
                    }
                    break;
                }
            }
        }
    }
}

Bir storeMessage ekledim() iletileri faaliyeti durdurulmuş durumda bile hemen işlenmesi gerekir diye PausedHandler sınıfına yöntemi. Eğer bir mesaj sonra yanlış işlenmiş ise iade edilmelidir ve mesaj atılacak.