/home/leaf/crossfire/jxclient/trunk/network/src/main/java/com/realtime/crossfire/jxclient/metaserver/MetaserverProcessor.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff.
 * Copyright (C) 2006-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.metaserver;

import com.realtime.crossfire.jxclient.guistate.ClientSocketState;
import com.realtime.crossfire.jxclient.guistate.GuiStateListener;
import com.realtime.crossfire.jxclient.guistate.GuiStateManager;
import org.jetbrains.annotations.NotNull;

public class MetaserverProcessor {

    private static final int UPDATE_INTERVAL = 15*60;

    private static final int MIN_UPDATE_INTERVAL = 5*60;

    @NotNull
    private final Metaserver metaserver;

    @NotNull
    private final Object sync = new Object();

    private boolean running = false;

    private int counter = UPDATE_INTERVAL;

    private long nextQuery = System.currentTimeMillis();

    @NotNull
    private final Runnable runnable = new Runnable() {

        @Override
        public void run() {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    boolean executeProcess = false;
                    synchronized (sync) {
                        //noinspection UnconditionalWait,WaitWithoutCorrespondingNotify
                        sync.wait(1000);
                        if (counter > 0) {
                            counter--;
                            if (counter == 0) {
                                executeProcess = true;
                                counter = UPDATE_INTERVAL;
                            }
                        }
                    }
                    if (executeProcess) {
                        final long now = System.currentTimeMillis();
                        if (nextQuery <= now) {
                            nextQuery = now+MIN_UPDATE_INTERVAL;
                            metaserver.updateMetaList();
                        }
                    }
                }
            } catch (final InterruptedException ignored) {
                // ignore
            }
        }

    };

    @NotNull
    private final GuiStateListener guiStateListener = new GuiStateListener() {

        @Override
        public void start() {
            // ignore
        }

        @Override
        public void metaserver() {
            query();
        }

        @Override
        public void preConnecting(@NotNull final String serverInfo) {
            // ignore
        }

        @Override
        public void connecting(@NotNull final String serverInfo) {
            disable();
        }

        @Override
        public void connecting(@NotNull final ClientSocketState clientSocketState) {
            // ignore
        }

        @Override
        public void connected() {
            // ignore
        }

        @Override
        public void connectFailed(@NotNull final String reason) {
            // ignore
        }

    };

    public MetaserverProcessor(@NotNull final Metaserver metaserver, @NotNull final GuiStateManager guiStateManager) {
        this.metaserver = metaserver;
        guiStateManager.addGuiStateListener(guiStateListener);
        query();
    }

    public void query() {
        synchronized (sync) {
            if (!running) {
                running = true;
                new Thread(runnable, "JXClient:MetaserverProcessor").start();
            }
            counter = 1;
        }
    }

    public void disable() {
        synchronized (sync) {
            counter = 0;
        }
    }

}

---