// 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.content.ContentResolver;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.SystemClock;
import com.olio.data.object.bluetooth_status.BluetoothNotificationObserver;
import com.olio.data.object.bluetooth_status.BluetoothStatus;
import com.olio.util.ALog;
import com.olio.util.RecoveryTimer;
import java.lang.ref.WeakReference;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.PriorityQueue;

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

public class DetectorManager
{
    private class DetectorScheduler
        implements Runnable
    {

        static final boolean $assertionsDisabled;
        Job 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 Job(((ManagedDetector) (obj)));
                    obj.nextRun = (long)(i * 1000) + l;
                    schedule.add(obj);
                }
                i++;
            }
        }

        private void scheduleNextJob()
        {
            if (schedule.isEmpty())
            {
                return;
            } else
            {
                mNextJob = (Job)schedule.poll();
                long l = mNextJob.nextRun;
                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.nextRun = SystemClock.elapsedRealtime() + manageddetector.longValue();
                schedule.add(mNextJob);
                return;
            }
        }

        public void run()
        {
            while (mStopped || mNextJob == null) 
            {
                return;
            }
            ManagedDetector manageddetector = (ManagedDetector)mNextJob.job.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 = (Job)schedule.poll();
            if (mNextJob == null)
            {
                return;
            } else
            {
                mTimer.startOrRestart((int)(mNextJob.nextRun - 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 DetectorScheduler()
        {
            this$0 = DetectorManager.this;
            super();
            mStopped = false;
            schedule = new PriorityQueue(mDetectors.size(), new _cls1());
        }
    }

    private static class Job
    {

        public final WeakReference job;
        public long nextRun;

        private Job(ManagedDetector manageddetector)
        {
            job = new WeakReference(manageddetector);
        }

    }


    final Context mContext;
    final List mDetectors;
    final DetectorScheduler mScheduler = new DetectorScheduler();
    final BluetoothNotificationObserver observer;

    public DetectorManager(List list, Context context, com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.Platform platform)
    {
        mDetectors = list;
        mContext = context;
        observer = new BluetoothNotificationObserver(null, platform, list) {

            final DetectorManager this$0;
            final List val$detectors;

            public void connectionStatusUpdate(com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.ConnectionStatusChange connectionstatuschange)
            {
                if (connectionstatuschange == com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.ConnectionStatusChange.CONNECTED)
                {
                    ALog.i("connectionStatusUpdate CONNECTED", new Object[0]);
                    connectionstatuschange = detectors.iterator();
                    do
                    {
                        if (!connectionstatuschange.hasNext())
                        {
                            break;
                        }
                        ManagedDetector manageddetector = (ManagedDetector)connectionstatuschange.next();
                        if (manageddetector.updateOnReconnect())
                        {
                            manageddetector.update();
                        }
                    } while (true);
                } else
                if (connectionstatuschange == com.olio.data.object.bluetooth_status.BluetoothNotificationObserver.ConnectionStatusChange.DISCONNECTED)
                {
                    ALog.i("connectionStatusUpdate DISCONNECTED", new Object[0]);
                    for (connectionstatuschange = detectors.iterator(); connectionstatuschange.hasNext(); ((ManagedDetector)connectionstatuschange.next()).onDisconnect()) { }
                } else
                {
                    ALog.w("connectionStatusUpdate UNKNOWN", new Object[0]);
                }
            }

            public void statusUpdate(BluetoothStatus bluetoothstatus)
            {
                ALog.i("statusUpdate", new Object[0]);
            }

            
            {
                this$0 = DetectorManager.this;
                detectors = list;
                super(final_contentresolver, handler, platform);
            }
        };
    }

    public void register()
    {
        ALog.i("Registering BT observer", new Object[0]);
        observer.register();
        start();
    }

    public void start()
    {
        for (Iterator iterator = mDetectors.iterator(); iterator.hasNext(); ((ManagedDetector)iterator.next()).register()) { }
        mScheduler.start(mDetectors);
    }

    public void stop()
    {
        for (Iterator iterator = mDetectors.iterator(); iterator.hasNext(); ((ManagedDetector)iterator.next()).unregister()) { }
        mScheduler.stop();
    }

    public void unregister()
    {
        stop();
        ALog.i("Unregistering BT observer", new Object[0]);
        observer.unregister();
    }

    // Unreferenced inner class com/olio/olios/detector/DetectorManager$DetectorScheduler$1

/* anonymous class */
    class DetectorScheduler._cls1
        implements Comparator
    {

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

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

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

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

}