haiku.git

/*
 * Copyright 2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


//!	The backbone of the NetworkAvailable event, and condition.


#include "NetworkWatcher.h"

#include <Application.h>
#include <Autolock.h>
#include <NetworkDevice.h>
#include <NetworkInterface.h>
#include <NetworkRoster.h>

#include "Utility.h"


static const bigtime_t kNetworkUpdateInterval = 1000000;
	// Update network availability every second

static BLocker sLocker("network watcher");
static NetworkWatcher* sWatcher;

static bool sLastNetworkAvailable;
static bigtime_t sLastNetworkUpdate;


NetworkListener::~NetworkListener()
{
}


// #pragma mark -


NetworkWatcher::NetworkWatcher()
	:
	BHandler("network watcher"),
	fAvailable(false)
{
	if (be_app->Lock()) {
		be_app->AddHandler(this);

		start_watching_network(B_WATCH_NETWORK_INTERFACE_CHANGES
			| B_WATCH_NETWORK_LINK_CHANGES, this);
		be_app->Unlock();
	}
}


NetworkWatcher::~NetworkWatcher()
{
	if (be_app->Lock()) {
		stop_watching_network(this);

		be_app->RemoveHandler(this);
		be_app->Unlock();
	}
}


void
NetworkWatcher::AddListener(NetworkListener* listener)
{
	BAutolock lock(sLocker);
	fListeners.AddItem(listener);

	if (fListeners.CountItems() == 1)
		UpdateAvailability();
}


void
NetworkWatcher::RemoveListener(NetworkListener* listener)
{
	BAutolock lock(sLocker);
	fListeners.RemoveItem(listener);
}


int32
NetworkWatcher::CountListeners() const
{
	BAutolock lock(sLocker);
	return fListeners.CountItems();
}


void
NetworkWatcher::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_NETWORK_MONITOR:
			UpdateAvailability();
			break;
	}
}


/*static*/ void
NetworkWatcher::Register(NetworkListener* listener)
{
	BAutolock lock(sLocker);
	if (sWatcher == NULL)
		sWatcher = new NetworkWatcher();

	sWatcher->AddListener(listener);
}


/*static*/ void
NetworkWatcher::Unregister(NetworkListener* listener)
{
	BAutolock lock(sLocker);
	sWatcher->RemoveListener(listener);

	if (sWatcher->CountListeners() == 0)
		delete sWatcher;
}


/*static*/ bool
NetworkWatcher::NetworkAvailable(bool immediate)
{
	if (!immediate
		&& system_time() - sLastNetworkUpdate < kNetworkUpdateInterval) {
		return sLastNetworkAvailable;
	}

	bool isAvailable = false;

	BNetworkRoster& roster = BNetworkRoster::Default();
	BNetworkInterface interface;
	uint32 cookie = 0;
	while (roster.GetNextInterface(&cookie, interface) == B_OK) {
		uint32 flags = interface.Flags();
		if ((flags & (IFF_LOOPBACK | IFF_CONFIGURING | IFF_UP | IFF_LINK))
				== (IFF_UP | IFF_LINK)) {
			isAvailable = true;
			break;
		}
	}

	sLastNetworkAvailable = isAvailable;
	sLastNetworkUpdate = system_time();
	return isAvailable;
}


void
NetworkWatcher::UpdateAvailability()
{
	bool isAvailable = NetworkAvailable(true);
	if (isAvailable != fAvailable) {
		fAvailable = isAvailable;

		BAutolock lock(sLocker);
		for (int32 i = 0; i < fListeners.CountItems(); i++) {
			fListeners.ItemAt(i)->NetworkAvailabilityChanged(fAvailable);
		}
	}
}