overallstatsimpl.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   OverallStatsImpl.java

package org.gudy.azureus2.core3.stats.transfer.impl;

import com.aelitis.azureus.core.*;
import com.aelitis.azureus.core.stats.AzureusCoreStats;
import com.aelitis.azureus.core.stats.AzureusCoreStatsProvider;
import java.util.*;
import org.gudy.azureus2.core3.global.*;
import org.gudy.azureus2.core3.stats.transfer.OverallStats;
import org.gudy.azureus2.core3.util.*;

public class OverallStatsImpl extends GlobalManagerAdapter
	implements OverallStats
{

	private static final long TEN_YEARS = 0x12cc0300L;
	private static final long STATS_PERIOD = 60000L;
	private AzureusCore core;
	private long totalDownloaded;
	private long totalUploaded;
	private long totalUptime;
	private long lastDownloaded;
	private long lastUploaded;
	private long lastUptime;
	private long totalProtocolUploaded;
	private long totalDataUploaded;
	private long totalProtocolDownloaded;
	private long totalDataDownloaded;
	private long lastProtocolUploaded;
	private long lastDataUploaded;
	private long lastProtocolDownloaded;
	private long lastDataDownloaded;
	private long session_start_time;
	protected AEMonitor this_mon;
	private int tick_count;

	private Map load(String filename)
	{
		return FileUtil.readResilientConfigFile(filename);
	}

	private Map load()
	{
		return load("azureus.statistics");
	}

	private void save(String filename, Map map)
	{
		this_mon.enter();
		FileUtil.writeResilientConfigFile(filename, map);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_32;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}

	private void save(Map map)
	{
		save("azureus.statistics", map);
	}

	private void validateAndLoadValues(Map statisticsMap)
	{
		lastUptime = SystemTime.getCurrentTime() / 1000L;
		Map overallMap = (Map)statisticsMap.get("all");
		totalDownloaded = getLong(overallMap, "downloaded");
		totalUploaded = getLong(overallMap, "uploaded");
		totalUptime = getLong(overallMap, "uptime");
		totalProtocolUploaded = getLong(overallMap, "p_uploaded");
		totalDataUploaded = getLong(overallMap, "d_uploaded");
		totalProtocolDownloaded = getLong(overallMap, "p_downloaded");
		totalDataDownloaded = getLong(overallMap, "d_downloaded");
	}

	protected long getLong(Map map, String name)
	{
		if (map == null)
			return 0L;
		Object obj = map.get(name);
		if (!(obj instanceof Long))
			return 0L;
		else
			return ((Long)obj).longValue();
	}

	public OverallStatsImpl(AzureusCore _core)
	{
		session_start_time = SystemTime.getCurrentTime();
		this_mon = new AEMonitor("OverallStats");
		core = _core;
		Map stats = load();
		validateAndLoadValues(stats);
		Set types = new HashSet();
		types.add("xfer.upload.protocol.bytes.total");
		types.add("xfer.upload.data.bytes.total");
		types.add("xfer.download.protocol.bytes.total");
		types.add("xfer.download.data.bytes.total");
		AzureusCoreStats.registerProvider(types, new AzureusCoreStatsProvider() {

			final OverallStatsImpl this$0;

			public void updateStats(Set types, Map values)
			{
				if (types.contains("xfer.upload.protocol.bytes.total"))
					values.put("xfer.upload.protocol.bytes.total", new Long(totalProtocolUploaded));
				if (types.contains("xfer.upload.data.bytes.total"))
					values.put("xfer.upload.data.bytes.total", new Long(totalDataUploaded));
				if (types.contains("xfer.download.protocol.bytes.total"))
					values.put("xfer.download.protocol.bytes.total", new Long(totalProtocolDownloaded));
				if (types.contains("xfer.download.data.bytes.total"))
					values.put("xfer.download.data.bytes.total", new Long(totalDataDownloaded));
			}

			
			{
				this$0 = OverallStatsImpl.this;
				super();
			}
		});
		core.addLifecycleListener(new AzureusCoreLifecycleAdapter() {

			final OverallStatsImpl this$0;

			public void componentCreated(AzureusCore core, AzureusCoreComponent component)
			{
				if (component instanceof GlobalManager)
				{
					GlobalManager gm = (GlobalManager)component;
					gm.addListener(OverallStatsImpl.this, false);
					SimpleTimer.addPeriodicEvent("OverallStats", 60000L, new TimerEventPerformer() {

						final 2 this$1;

						public void perform(TimerEvent event)
						{
							updateStats(false);
						}

					
					{
						this$1 = 2.this;
						super();
					}
					});
				}
			}

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

	public int getAverageDownloadSpeed()
	{
		if (totalUptime > 1L)
			return (int)(totalDownloaded / totalUptime);
		else
			return 0;
	}

	public int getAverageUploadSpeed()
	{
		if (totalUptime > 1L)
			return (int)(totalUploaded / totalUptime);
		else
			return 0;
	}

	public long getDownloadedBytes()
	{
		return totalDownloaded;
	}

	public long getUploadedBytes()
	{
		return totalUploaded;
	}

	public long getTotalUpTime()
	{
		return totalUptime;
	}

	public long getSessionUpTime()
	{
		return (SystemTime.getCurrentTime() - session_start_time) / 1000L;
	}

	public void destroyInitiated()
	{
		updateStats(true);
	}

	private void updateStats(boolean force)
	{
		long current_time;
		this_mon.enter();
		current_time = SystemTime.getCurrentTime() / 1000L;
		if (current_time >= lastUptime)
			break MISSING_BLOCK_LABEL_37;
		lastUptime = current_time;
		this_mon.exit();
		return;
		long delta;
		GlobalManagerStats stats = core.getGlobalManager().getStats();
		long current_total_d_received = stats.getTotalDataBytesReceived();
		long current_total_p_received = stats.getTotalProtocolBytesReceived();
		long current_total_d_sent = stats.getTotalDataBytesSent();
		long current_total_p_sent = stats.getTotalProtocolBytesSent();
		long current_total_received = current_total_d_received + current_total_p_received;
		long current_total_sent = current_total_d_sent + current_total_p_sent;
		totalDownloaded += current_total_received - lastDownloaded;
		lastDownloaded = current_total_received;
		if (totalDownloaded < 0L)
			totalDownloaded = 0L;
		totalUploaded += current_total_sent - lastUploaded;
		lastUploaded = current_total_sent;
		if (totalUploaded < 0L)
			totalUploaded = 0L;
		totalDataDownloaded += current_total_d_received - lastDataDownloaded;
		lastDataDownloaded = current_total_d_received;
		if (totalDataDownloaded < 0L)
			totalDataDownloaded = 0L;
		totalProtocolDownloaded += current_total_p_received - lastProtocolDownloaded;
		lastProtocolDownloaded = current_total_p_received;
		if (totalProtocolDownloaded < 0L)
			totalProtocolDownloaded = 0L;
		totalDataUploaded += current_total_d_sent - lastDataUploaded;
		lastDataUploaded = current_total_d_sent;
		if (totalDataUploaded < 0L)
			totalDataUploaded = 0L;
		totalProtocolUploaded += current_total_p_sent - lastProtocolUploaded;
		lastProtocolUploaded = current_total_p_sent;
		if (totalProtocolUploaded < 0L)
			totalProtocolUploaded = 0L;
		delta = current_time - lastUptime;
		if (delta <= 100L && delta >= 0L)
			break MISSING_BLOCK_LABEL_356;
		lastUptime = current_time;
		this_mon.exit();
		return;
		if (totalUptime > 0x12cc0300L)
			totalUptime = 0L;
		if (totalUptime < 0L)
			totalUptime = 0L;
		totalUptime += delta;
		lastUptime = current_time;
		tick_count++;
		HashMap overallMap = new HashMap();
		overallMap.put("downloaded", new Long(totalDownloaded));
		overallMap.put("uploaded", new Long(totalUploaded));
		overallMap.put("uptime", new Long(totalUptime));
		overallMap.put("p_uploaded", new Long(totalProtocolUploaded));
		overallMap.put("d_uploaded", new Long(totalDataUploaded));
		overallMap.put("p_downloaded", new Long(totalProtocolDownloaded));
		overallMap.put("d_downloaded", new Long(totalDataDownloaded));
		Map map = new HashMap();
		map.put("all", overallMap);
		save(map);
		this_mon.exit();
		break MISSING_BLOCK_LABEL_603;
		Exception exception;
		exception;
		this_mon.exit();
		throw exception;
	}





}