// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package org.jdeferred.android;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import org.jdeferred.AlwaysCallback;
import org.jdeferred.Deferred;
import org.jdeferred.DoneCallback;
import org.jdeferred.FailCallback;
import org.jdeferred.ProgressCallback;
import org.jdeferred.Promise;
import org.jdeferred.impl.DeferredObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// Referenced classes of package org.jdeferred.android:
//            AndroidExecutionScope, AndroidExecutionScopeable

public class AndroidDeferredObject extends DeferredObject
{
    private static class CallbackMessage
    {

        final Object callback;
        final Deferred deferred;
        final Object progress;
        final Object rejected;
        final Object resolved;
        final org.jdeferred.Promise.State state;

        CallbackMessage(Deferred deferred1, Object obj, org.jdeferred.Promise.State state1, Object obj1, Object obj2, Object obj3)
        {
            deferred = deferred1;
            callback = obj;
            state = state1;
            resolved = obj1;
            rejected = obj2;
            progress = obj3;
        }
    }

    private static class InternalHandler extends Handler
    {

        public void handleMessage(Message message)
        {
            CallbackMessage callbackmessage = (CallbackMessage)message.obj;
            switch (message.what)
            {
            default:
                return;

            case 1: // '\001'
                ((DoneCallback)callbackmessage.callback).onDone(callbackmessage.resolved);
                return;

            case 2: // '\002'
                ((ProgressCallback)callbackmessage.callback).onProgress(callbackmessage.progress);
                return;

            case 3: // '\003'
                ((FailCallback)callbackmessage.callback).onFail(callbackmessage.rejected);
                return;

            case 4: // '\004'
                ((AlwaysCallback)callbackmessage.callback).onAlways(callbackmessage.state, callbackmessage.resolved, callbackmessage.rejected);
                break;
            }
        }

        public InternalHandler()
        {
            super(Looper.getMainLooper());
        }
    }


    private static final int MESSAGE_POST_ALWAYS = 4;
    private static final int MESSAGE_POST_DONE = 1;
    private static final int MESSAGE_POST_FAIL = 3;
    private static final int MESSAGE_POST_PROGRESS = 2;
    private static final InternalHandler sHandler = new InternalHandler();
    private final AndroidExecutionScope defaultAndroidExecutionScope;
    protected final Logger log;

    public AndroidDeferredObject(Promise promise)
    {
        this(promise, AndroidExecutionScope.UI);
    }

    public AndroidDeferredObject(Promise promise, AndroidExecutionScope androidexecutionscope)
    {
        log = LoggerFactory.getLogger(org/jdeferred/android/AndroidDeferredObject);
        defaultAndroidExecutionScope = androidexecutionscope;
        promise.done(new DoneCallback() {

            final AndroidDeferredObject this$0;

            public void onDone(Object obj)
            {
                resolve(obj);
            }

            
            {
                this$0 = AndroidDeferredObject.this;
                super();
            }
        }).progress(new ProgressCallback() {

            final AndroidDeferredObject this$0;

            public void onProgress(Object obj)
            {
                notify(obj);
            }

            
            {
                this$0 = AndroidDeferredObject.this;
                super();
            }
        }).fail(new FailCallback() {

            final AndroidDeferredObject this$0;

            public void onFail(Object obj)
            {
                reject(obj);
            }

            
            {
                this$0 = AndroidDeferredObject.this;
                super();
            }
        });
    }

    protected AndroidExecutionScope determineAndroidExecutionScope(Object obj)
    {
        AndroidExecutionScope androidexecutionscope = null;
        if (obj instanceof AndroidExecutionScopeable)
        {
            androidexecutionscope = ((AndroidExecutionScopeable)obj).getExecutionScope();
        }
        obj = androidexecutionscope;
        if (androidexecutionscope == null)
        {
            obj = defaultAndroidExecutionScope;
        }
        return ((AndroidExecutionScope) (obj));
    }

    protected void executeInUiThread(int i, Object obj, org.jdeferred.Promise.State state, Object obj1, Object obj2, Object obj3)
    {
        sHandler.obtainMessage(i, new CallbackMessage(this, obj, state, obj1, obj2, obj3)).sendToTarget();
    }

    protected void triggerAlways(AlwaysCallback alwayscallback, org.jdeferred.Promise.State state, Object obj, Object obj1)
    {
        if (determineAndroidExecutionScope(alwayscallback) == AndroidExecutionScope.UI)
        {
            executeInUiThread(4, alwayscallback, state, obj, obj1, null);
            return;
        } else
        {
            super.triggerAlways(alwayscallback, state, obj, obj1);
            return;
        }
    }

    protected void triggerDone(DoneCallback donecallback, Object obj)
    {
        if (determineAndroidExecutionScope(donecallback) == AndroidExecutionScope.UI)
        {
            executeInUiThread(1, donecallback, org.jdeferred.Promise.State.RESOLVED, obj, null, null);
            return;
        } else
        {
            super.triggerDone(donecallback, obj);
            return;
        }
    }

    protected void triggerFail(FailCallback failcallback, Object obj)
    {
        if (determineAndroidExecutionScope(failcallback) == AndroidExecutionScope.UI)
        {
            executeInUiThread(3, failcallback, org.jdeferred.Promise.State.REJECTED, null, obj, null);
            return;
        } else
        {
            super.triggerFail(failcallback, obj);
            return;
        }
    }

    protected void triggerProgress(ProgressCallback progresscallback, Object obj)
    {
        if (determineAndroidExecutionScope(progresscallback) == AndroidExecutionScope.UI)
        {
            executeInUiThread(2, progresscallback, org.jdeferred.Promise.State.PENDING, null, null, obj);
            return;
        } else
        {
            super.triggerProgress(progresscallback, obj);
            return;
        }
    }

}