// 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 com.olio.olios.detector;

import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import com.olio.util.ALog;
import com.olio.util.RecoveryTimer;
import java.lang.ref.WeakReference;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;

// Referenced classes of package com.olio.olios.detector:
//            DetectorManager, ManagedDetector

private class _cls1.compare
    implements Runnable
{

    static final boolean $assertionsDisabled;
    .assertionsDisabled mNextJob;
    private volatile boolean mStopped;
    final RecoveryTimer mTimer = new RecoveryTimer("DetectorManager");
    PriorityQueue schedule;
    final DetectorManager this$0;

    private void init(long l, List list)
    {
        schedule.clear();
        int i = 0;
        while (i < list.size()) 
        {
            Object obj = (ManagedDetector)list.get(i);
            if (((ManagedDetector) (obj)).updateFrequency() != null)
            {
                obj = new schedule(((ManagedDetector) (obj)), null);
                obj.schedule = (long)(i * 1000) + l;
                schedule.add(obj);
            }
            i++;
        }
    }

    private void scheduleNextJob()
    {
        if (schedule.isEmpty())
        {
            return;
        } else
        {
            mNextJob = (mNextJob)schedule.poll();
            long l = mNextJob.mNextJob;
            long l1 = SystemClock.elapsedRealtime();
            mTimer.startOrRestart(l - l1, this);
            return;
        }
    }

    private void updateDetector(ManagedDetector manageddetector)
    {
        if (manageddetector.shouldUpdate())
        {
            manageddetector.update();
        }
    }

    private void updateJobNextExecution(ManagedDetector manageddetector)
    {
        manageddetector = manageddetector.updateFrequency();
        if (!$assertionsDisabled && manageddetector == null)
        {
            throw new AssertionError();
        } else
        {
            mNextJob.mNextJob = SystemClock.elapsedRealtime() + manageddetector.longValue();
            schedule.add(mNextJob);
            return;
        }
    }

    public void run()
    {
        while (mStopped || mNextJob == null) 
        {
            return;
        }
        ManagedDetector manageddetector = (ManagedDetector)mNextJob.mNextJob.get();
        if (manageddetector == null)
        {
            ALog.e("A detector reference was lost!", new Object[0]);
            scheduleNextJob();
            return;
        } else
        {
            updateDetector(manageddetector);
            updateJobNextExecution(manageddetector);
            scheduleNextJob();
            return;
        }
    }

    public void start(List list)
    {
        mStopped = false;
        long l = SystemClock.elapsedRealtime();
        init(l, list);
        mTimer.init(mContext, new Handler(Looper.getMainLooper()));
        mNextJob = (mNextJob)schedule.poll();
        if (mNextJob == null)
        {
            return;
        } else
        {
            mTimer.startOrRestart((int)(mNextJob.mNextJob - l), this);
            return;
        }
    }

    public void stop()
    {
        mStopped = true;
        mTimer.dispose();
        schedule.clear();
    }

    static 
    {
        boolean flag;
        if (!com/olio/olios/detector/DetectorManager.desiredAssertionStatus())
        {
            flag = true;
        } else
        {
            flag = false;
        }
        $assertionsDisabled = flag;
    }

    public _cls1.val.this._cls0()
    {
        this.this$0 = DetectorManager.this;
        super();
        mStopped = false;
        schedule = new PriorityQueue(mDetectors.size(), new Comparator() {

            final DetectorManager.DetectorScheduler this$1;
            final DetectorManager val$this$0;

            public int compare(DetectorManager.Job job, DetectorManager.Job job1)
            {
                return Long.compare(job.nextRun, job1.nextRun);
            }

            public volatile int compare(Object obj, Object obj1)
            {
                return compare((DetectorManager.Job)obj, (DetectorManager.Job)obj1);
            }

            
            {
                this$1 = DetectorManager.DetectorScheduler.this;
                this$0 = detectormanager;
                super();
            }
        });
    }
}