Unify local/global devices and tuners into a single coherent service

39 files changed, 636 insertions, 688 deletions

diff --git a/p2pvr/carddaemon/carddaemon.cpp b/p2pvr/carddaemon/carddaemon.cpp
index f7889e8..c20ca4e 100644
--- a/p2pvr/carddaemon/carddaemon.cpp
+++ b/p2pvr/carddaemon/carddaemon.cpp
@@ -1,5 +1,5 @@
 #include <icetrayService.h>
-#include "localDevices.h"
+#include "devices.h"
 #include <Ice/ObjectAdapter.h>
 #include <Ice/Communicator.h>
 #include <IceUtil/Timer.h>
@@ -9,8 +9,7 @@ class CardDaemon : public IceTray::Service {
 	public:
 		void addObjects(const std::string &, const Ice::CommunicatorPtr & ic, const Ice::StringSeq &, const Ice::ObjectAdapterPtr & adapter) override
 		{
-			IceUtil::TimerPtr timer = new IceUtil::Timer();
-			adapter->add(new LocalDevicesI(adapter, timer), ic->stringToIdentity("Devices"));
+			adapter->add(new DevicesI(), ic->stringToIdentity("Devices"));
 		}
 };
 
diff --git a/p2pvr/daemon/daemon.cpp b/p2pvr/daemon/daemon.cpp
index c19f5cf..3a3b40f 100644
--- a/p2pvr/daemon/daemon.cpp
+++ b/p2pvr/daemon/daemon.cpp
@@ -1,5 +1,4 @@
-#include "localDevices.h"
-#include "globalDevices.h"
+#include "devices.h"
 #include "maintenance.h"
 #include "si.h"
 #include "schedules.h"
@@ -37,8 +36,7 @@ class P2PvrDaemon : public IceTray::Service {
 
 			IceUtil::TimerPtr timer = new IceUtil::Timer();
 			auto db = getConnectionPool(ic, "postgresql", "postgres");
-			auto localDevices = add<LocalDevices>(ic, adapter, new LocalDevicesI(adapter, timer), "Devices");
-			auto globalDevices = add<Devices>(ic, adapter, new GlobalDevices(), "GlobalDevices");
+			auto devices = add<Tuners>(ic, adapter, new DevicesI(), "Devices");
 			auto maintenance = add<Maintenance>(ic, adapter, new MaintenanceI(db, adapter, timer), "Maintenance");
 			auto si = add<SI>(ic, adapter, new SII(db), "SI");
 			auto schedules = add<Schedules>(ic, adapter, new SchedulesI(db), "Schedules");
diff --git a/p2pvr/daemon/globalDevices.cpp b/p2pvr/daemon/globalDevices.cpp
deleted file mode 100644
index 0705415..0000000
--- a/p2pvr/daemon/globalDevices.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "globalDevices.h"
-#include <Ice/Ice.h>
-
-namespace po = boost::program_options;
-
-namespace P2PVR {
-GlobalDevices::Options::Options() :
-	IceTray::Options("P2PVR Devices")
-{
-}
-
-ICETRAY_OPTIONS(GlobalDevices::Options,
-		("p2pvr.globaldevices.carddaemon", po::value(&Devices),
-		 "ICE address of remote device pools (<object>:<endpoint>)")
-)
-
-TunerPrx
-GlobalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
-{
-	auto ic = ice.adapter->getCommunicator();
-	for (const auto & pool : options->Devices) {
-		try {
-			auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
-			return poolprx->GetTunerSpecific(delivery);
-		}
-		catch (...) {
-		}
-	}
-	throw NoSuitableDeviceAvailable();
-}
-
-TunerPrx
-GlobalDevices::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
-{
-	auto ic = ice.adapter->getCommunicator();
-	for (const auto & pool : options->Devices) {
-		try {
-			auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
-			return poolprx->GetTunerAny(delivery);
-		}
-		catch (...) {
-		}
-	}
-	throw NoSuitableDeviceAvailable();
-}
-
-PrivateTunerPrx
-GlobalDevices::GetPrivateTuner(short type, const Ice::Current & ice)
-{
-	auto ic = ice.adapter->getCommunicator();
-	for (const auto & pool : options->Devices) {
-		try {
-			auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
-			return poolprx->GetPrivateTuner(type);
-		}
-		catch (...) {
-		}
-	}
-	throw NoSuitableDeviceAvailable();
-}
-
-void
-GlobalDevices::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
-{
-	auto ic = ice.adapter->getCommunicator();
-	for (const auto & pool : options->Devices) {
-		auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
-		poolprx->ReleaseTuner(tuner);
-	}
-}
-
-int
-GlobalDevices::TunerCount(const Ice::Current & ice)
-{
-	int total = 0;
-	auto ic = ice.adapter->getCommunicator();
-	for (const auto & pool : options->Devices) {
-		try {
-			auto poolprx = DevicesPrx::checkedCast(ic->stringToProxy(pool));
-			total += poolprx->TunerCount();
-		}
-		catch (...) {
-			// Not available, don't count 'em
-		}
-	}
-	return total;
-}
-}
-
diff --git a/p2pvr/daemon/globalDevices.h b/p2pvr/daemon/globalDevices.h
deleted file mode 100644
index 43a7dc3..0000000
--- a/p2pvr/daemon/globalDevices.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef GLOBALDEVICES_H
-#define GLOBALDEVICES_H
-
-// Global devices implements a device collection (Devices) for any devices known
-// throughout the system through other Devices interfaces
-
-#include <dvb.h>
-#include <options.h>
-
-namespace P2PVR {
-class GlobalDevices : public Devices {
-	public:
-		class Options : public IceTray::Options {
-			public:
-				Options();
-
-				ICETRAY_OPTIONS_DECLARE;
-
-				std::vector<std::string> Devices;
-		};
-
-		TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
-		TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
-		PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
-		void ReleaseTuner(const TunerPrx &, const Ice::Current &);
-		int TunerCount(const Ice::Current &);
-
-	private:
-		IceTray::OptionsResolver<Options> options;
-};
-}
-
-#endif
-
-
diff --git a/p2pvr/daemon/maintenance/events.cpp b/p2pvr/daemon/maintenance/events.cpp
index 05c9149..2dd91af 100644
--- a/p2pvr/daemon/maintenance/events.cpp
+++ b/p2pvr/daemon/maintenance/events.cpp
@@ -43,7 +43,7 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 		void Produce(const Consumer & ch) override
 		{
 			auto ic = ice.adapter->getCommunicator();
-			auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+			auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
 			auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
 			if (!devs || !si) {
 				throw std::runtime_error("bad proxy(s)");
@@ -54,12 +54,10 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 				throw std::runtime_error("no delivery methods");
 			}
 			logger->messagebf(LOG::DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__);
-			auto tuner = devs->GetTunerAny(delivery);
 			logger->messagebf(LOG::DEBUG, "%s: Fetching events", __PRETTY_FUNCTION__);
 			TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, new SiEventsHandler(ch, logger));
 
-			tuner->SendEventInformation(parser);
-			devs->ReleaseTuner(tuner);
+			devs->SendEventInformation(delivery, parser);
 		}
 
 	private:
diff --git a/p2pvr/daemon/maintenance/network.cpp b/p2pvr/daemon/maintenance/network.cpp
index 3e08628..c514175 100644
--- a/p2pvr/daemon/maintenance/network.cpp
+++ b/p2pvr/daemon/maintenance/network.cpp
@@ -72,11 +72,11 @@ class SiNetworkInformationMerger : public DVBSI::SiNetworkInformationParser {
 };
 
 void
-MaintenanceI::UpdateNetwork(short type, const Ice::Current & ice)
+MaintenanceI::UpdateNetwork(short, const Ice::Current & ice)
 {
 	auto dbc = db->get();
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+	auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
 	auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
 	auto siparser = new SiNetworkInformationMerger(dbc.get(), logger);
 	TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, siparser);
@@ -89,32 +89,11 @@ MaintenanceI::UpdateNetwork(short type, const Ice::Current & ice)
 
 	auto transport = si->GetDeliveryForSi();
 	if (transport) {
-		TunerPrx tuner;
-		try {
-			tuner = devs->GetTunerAny(transport);
-			tuner->SendNetworkInformation(parser);
-			devs->ReleaseTuner(tuner);
-			return;
-		}
-		catch (const NoSuitableDeviceAvailable &) {
-			logger->messagebf(LOG::WARNING, "%s: Failed to get a suitable tuner", __PRETTY_FUNCTION__);
-			throw;
-		}
-		catch (const std::exception & ex) {
-			logger->messagebf(LOG::WARNING, "%s: Failed to fetch network information: %s", __PRETTY_FUNCTION__, ex.what());
-			devs->ReleaseTuner(tuner);
-			throw;
-		}
-		catch (...) {
-			logger->messagebf(LOG::WARNING, "%s: Failed to fetch network information", __PRETTY_FUNCTION__);
-			devs->ReleaseTuner(tuner);
-			throw;
-		}
+		devs->SendNetworkInformation(transport, parser);
+		return;
 	}
 	// If we can't do that, do a complete scan
-	auto tuner = devs->GetPrivateTuner(type);
-	tuner->ScanAndSendNetworkInformation(parser);
-	devs->ReleaseTuner(tuner);
+	devs->ScanAndSendNetworkInformation(parser);
 }
 }
 
diff --git a/p2pvr/daemon/maintenance/services.cpp b/p2pvr/daemon/maintenance/services.cpp
index d83e68a..12b23ce 100644
--- a/p2pvr/daemon/maintenance/services.cpp
+++ b/p2pvr/daemon/maintenance/services.cpp
@@ -43,7 +43,7 @@ void
 MaintenanceI::UpdateServices(const Ice::Current & ice)
 {
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+	auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
 	auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
 
 	if (!devs || !si) {
@@ -60,12 +60,9 @@ MaintenanceI::UpdateServices(const Ice::Current & ice)
 	}
 
 	DB::TransactionScope tx(dbc.get());
-	logger->messagebf(LOG::DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__);
-	auto tuner = devs->GetTunerAny(delivery);
 	logger->messagebf(LOG::DEBUG, "%s: Fetching service list", __PRETTY_FUNCTION__);
-	tuner->SendServiceDescriptions(parser);
+	devs->SendServiceDescriptions(delivery, parser);
 	logger->messagebf(LOG::INFO, "%s: Updated service list", __PRETTY_FUNCTION__);
-	devs->ReleaseTuner(tuner);
 }
 }
 
diff --git a/p2pvr/daemon/recorder.cpp b/p2pvr/daemon/recorder.cpp
index c797d04..f32eb73 100644
--- a/p2pvr/daemon/recorder.cpp
+++ b/p2pvr/daemon/recorder.cpp
@@ -56,7 +56,7 @@ RecorderI::StartRecording(SchedulePtr schedule, ::DVBSI::ServicePtr service, Eve
 	std::lock_guard<std::mutex> g(lock);
 	auto storage = StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
 	auto recordings = RecordingsPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Recordings")));
-	auto devices = DevicesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("GlobalDevices")));
+	auto devices = TunersPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Devices")));
 	auto si = SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
 
 	auto recordingId = recordings->NewRecording(new Recording(0, schedule->ScheduleId, event->EventUid));
diff --git a/p2pvr/daemon/schedules.cpp b/p2pvr/daemon/schedules.cpp
index 4fd2054..d948603 100644
--- a/p2pvr/daemon/schedules.cpp
+++ b/p2pvr/daemon/schedules.cpp
@@ -194,7 +194,7 @@ void
 SchedulesI::DoReschedule(const Ice::Current & ice)
 {
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices")));
+	auto devs = P2PVR::TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
 	unsigned int tunerCount = devs->TunerCount();
 
 	// Load list from database
diff --git a/p2pvr/daemon/unittests/mockDefs.cpp b/p2pvr/daemon/unittests/mockDefs.cpp
index 0bba8c0..8282492 100644
--- a/p2pvr/daemon/unittests/mockDefs.cpp
+++ b/p2pvr/daemon/unittests/mockDefs.cpp
@@ -28,8 +28,7 @@ StandardMockDatabasePlusOffset::StandardMockDatabasePlusOffset(const Ice::String
 }
 
 TestClient::TestClient() :
-	localDevices(getProxy<LocalDevicesPrx>("Devices")),
-	devices(getProxy<DevicesPrx>("GlobalDevices")),
+	devices(getProxy<TunersPrx>("Devices")),
 	maint(getProxy<MaintenancePrx>("Maintenance")),
 	si(getProxy<SIPrx>("SI")),
 	schedules(getProxy<SchedulesPrx>("Schedules")),
diff --git a/p2pvr/daemon/unittests/mockDefs.h b/p2pvr/daemon/unittests/mockDefs.h
index fa6490c..1589440 100644
--- a/p2pvr/daemon/unittests/mockDefs.h
+++ b/p2pvr/daemon/unittests/mockDefs.h
@@ -20,8 +20,7 @@ class DLL_PUBLIC TestClient : public IceTray::DryIceClient {
 	public:
 		TestClient();
 
-		LocalDevicesPrx localDevices;
-		DevicesPrx devices;
+		TunersPrx devices;
 		MaintenancePrx maint;
 		SIPrx si;
 		SchedulesPrx schedules;
diff --git a/p2pvr/daemon/unittests/mockDevices.cpp b/p2pvr/daemon/unittests/mockDevices.cpp
index f0ec930..3e04c85 100644
--- a/p2pvr/daemon/unittests/mockDevices.cpp
+++ b/p2pvr/daemon/unittests/mockDevices.cpp
@@ -3,31 +3,96 @@
 #include <Ice/ObjectAdapter.h>
 
 namespace P2PVR {
-namespace Testing {
-TunerPrx MockDevices::GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
-{
-	return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
-}
+	namespace Testing {
+		void MockDevices::ScanAndSendNetworkInformation(const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.ScanAndSendNetworkInformation(target);
+		}
 
-TunerPrx MockDevices::GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice)
-{
-	return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
-}
+		void MockDevices::SendNetworkInformation(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendNetworkInformation(target);
+		}
 
-PrivateTunerPrx MockDevices::GetPrivateTuner(Ice::Short, const Ice::Current & ice)
-{
-	return PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new MockTuner()));
-}
+		void MockDevices::SendBouquetAssociations(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendBouquetAssociations(target);
+		}
 
-void MockDevices::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
-{
-	ice.adapter->remove(tuner->ice_getIdentity());
-}
+		void MockDevices::SendServiceDescriptions(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendServiceDescriptions(target);
+		}
 
-Ice::Int MockDevices::TunerCount(const Ice::Current&)
-{
-	return 1;
-}
-}
+		void MockDevices::SendProgramAssociationTable(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendProgramAssociationTable(target);
+		}
+
+		void MockDevices::SendProgramMap(const ::DVBSI::DeliveryPtr & del, ::Ice::Int pid, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendProgramMap(pid, target);
+		}
+
+		void MockDevices::SendEventInformation(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			MockTuner mt(ice.adapter->getCommunicator());
+			mt.SendEventInformation(target);
+		}
+
+		::Ice::Int MockDevices::StartSendingTS(const ::DVBSI::DeliveryPtr & del, const PacketIds & pids, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			TunerPtr tuner = new MockTuner(ice.adapter->getCommunicator());
+			return bgOps.insert({ tuner->StartSendingTS(pids, target), tuner }).first->first;
+		}
+
+		::Ice::Int MockDevices::StartSendingSection(const ::DVBSI::DeliveryPtr & del, ::Ice::Int sid, const RawDataClientPrx & target, const ::Ice::Current & ice)
+		{
+			BOOST_ASSERT(del);
+			TunerPtr tuner = new MockTuner(ice.adapter->getCommunicator());
+			return bgOps.insert({ tuner->StartSendingSection(sid, target), tuner }).first->first;
+		}
+
+		void MockDevices::StopSending(::Ice::Int handle, const ::Ice::Current &)
+		{
+			BOOST_ASSERT(handle);
+			auto itr = bgOps.find(handle);
+			BOOST_ASSERT(itr != bgOps.end());
+			BOOST_ASSERT(itr->second);
+			itr->second->StopSending(handle);
+			bgOps.erase(itr);
+		}
+
+
+		void MockDevices::Scan(const std::string &, const Ice::Current &)
+		{
+		}
+
+		void MockDevices::Add(const std::string &, const Ice::Current &)
+		{
+		}
+
+		void MockDevices::Remove(const std::string &, const Ice::Current &)
+		{
+		}
+
+		::Ice::Int MockDevices::TunerCount(const Ice::Current &)
+		{
+			return 1;
+		}
+	}
 }
 
diff --git a/p2pvr/daemon/unittests/mockDevices.h b/p2pvr/daemon/unittests/mockDevices.h
index be04772..bc0a22a 100644
--- a/p2pvr/daemon/unittests/mockDevices.h
+++ b/p2pvr/daemon/unittests/mockDevices.h
@@ -5,16 +5,30 @@
 #include <visibility.h>
 
 namespace P2PVR {
-namespace Testing {
-class DLL_PUBLIC MockDevices : public Devices {
-	public:
-		TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
-		TunerPrx GetTunerAny(const DVBSI::DeliveryPtr&, const Ice::Current & ice) override;
-		PrivateTunerPrx GetPrivateTuner(Ice::Short, const Ice::Current & ice) override;
-		void ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice) override;
-		Ice::Int TunerCount(const Ice::Current&) override;
-};
-}
+	namespace Testing {
+		class DLL_PUBLIC MockDevices : public Tuners {
+			public:
+				virtual void ScanAndSendNetworkInformation(const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendNetworkInformation(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendBouquetAssociations(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendServiceDescriptions(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendProgramAssociationTable(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendProgramMap(const ::DVBSI::DeliveryPtr&, ::Ice::Int, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void SendEventInformation(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual ::Ice::Int StartSendingTS(const ::DVBSI::DeliveryPtr&, const PacketIds&, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual ::Ice::Int StartSendingSection(const ::DVBSI::DeliveryPtr&, ::Ice::Int, const RawDataClientPrx&, const ::Ice::Current&) override;
+				virtual void StopSending(::Ice::Int, const ::Ice::Current&) override;
+
+				void Scan(const std::string & path, const Ice::Current &) override;
+				void Add(const std::string & frontend, const Ice::Current &) override;
+				void Remove(const std::string & frontend, const Ice::Current &) override;
+				::Ice::Int TunerCount(const Ice::Current &) override;
+
+			private:
+				typedef std::map<::Ice::Int, TunerPtr> BackgroundOperations;
+				BackgroundOperations bgOps;
+		};
+	}
 }
 
 #endif
diff --git a/p2pvr/daemon/unittests/testErrorHandling.cpp b/p2pvr/daemon/unittests/testErrorHandling.cpp
index db07293..2ec1941 100644
--- a/p2pvr/daemon/unittests/testErrorHandling.cpp
+++ b/p2pvr/daemon/unittests/testErrorHandling.cpp
@@ -26,7 +26,7 @@ class Core : public StandardMockDatabase {
 	public:
 		Core()
 		{
-			replace("GlobalDevices", new MockDevices());
+			replace("Devices", new MockDevices());
 		}
 };
 
@@ -72,40 +72,36 @@ BOOST_AUTO_TEST_CASE(TestRawDataClient)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	auto gd = devices->GetTunerAny(del);
 	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestDataClient());
 	BOOST_TEST_CHECKPOINT("Make successful call");
-	gd->SendNetworkInformation(a);
+	devices->SendNetworkInformation(del, a);
 }
 
 BOOST_AUTO_TEST_CASE(TestParser)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	auto gd = devices->GetTunerAny(del);
 	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestNetworkParser());
 	BOOST_TEST_CHECKPOINT("Make successful call");
-	gd->SendNetworkInformation(a);
+	devices->SendNetworkInformation(del, a);
 }
 
 BOOST_AUTO_TEST_CASE(TestRawDataClientWithError)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	auto gd = devices->GetTunerAny(del);
 	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestClient());
 	BOOST_TEST_CHECKPOINT("Make failing call");
-	BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), DataHandlingException);
+	BOOST_REQUIRE_THROW(devices->SendNetworkInformation(del, a), DataHandlingException);
 }
 
 BOOST_AUTO_TEST_CASE(TestParserWithError)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	auto gd = devices->GetTunerAny(del);
 	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestNetworkParser());
 	BOOST_TEST_CHECKPOINT("Make failing call");
-	BOOST_REQUIRE_THROW(gd->SendNetworkInformation(a), DataHandlingException);
+	BOOST_REQUIRE_THROW(devices->SendNetworkInformation(del, a), DataHandlingException);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/p2pvr/daemon/unittests/testMaint.cpp b/p2pvr/daemon/unittests/testMaint.cpp
index 026ec27..a1fc6fd 100644
--- a/p2pvr/daemon/unittests/testMaint.cpp
+++ b/p2pvr/daemon/unittests/testMaint.cpp
@@ -27,7 +27,7 @@ class TestService : public SchemaOnlyMockDatabase {
 	public:
 		TestService()
 		{
-			replace("GlobalDevices", new MockDevices());
+			replace("Devices", new MockDevices());
 			replace("Schedules", new MockScheduler());
 		}
 };
diff --git a/p2pvr/daemon/unittests/testRecording.cpp b/p2pvr/daemon/unittests/testRecording.cpp
index e4dc6c1..fe81b7d 100644
--- a/p2pvr/daemon/unittests/testRecording.cpp
+++ b/p2pvr/daemon/unittests/testRecording.cpp
@@ -28,7 +28,7 @@ class TestService : public StandardMockDatabase {
 	public:
 		TestService()
 		{
-			replace("GlobalDevices", new MockDevices());
+			replace("Devices", new MockDevices());
 			replace("Schedules", new MockScheduler());
 		}
 };
diff --git a/p2pvr/daemon/unittests/testSched.cpp b/p2pvr/daemon/unittests/testSched.cpp
index badf35c..9f6881a 100644
--- a/p2pvr/daemon/unittests/testSched.cpp
+++ b/p2pvr/daemon/unittests/testSched.cpp
@@ -26,7 +26,7 @@ class TestService : public StandardMockDatabasePlusOffset {
 	public:
 		TestService()
 		{
-			replace("GlobalDevices", new MockDevices());
+			replace("Devices", new MockDevices());
 			replace("Recorder", new MockRecorder());
 		}
 };
diff --git a/p2pvr/devices/devices.cpp b/p2pvr/devices/devices.cpp
new file mode 100644
index 0000000..541cfa5
--- /dev/null
+++ b/p2pvr/devices/devices.cpp
@@ -0,0 +1,258 @@
+#include "devices.h"
+#include <Ice/Ice.h>
+#include "tuner.h"
+#include "bindTimerTask.h"
+#include <lockHelpers.h>
+
+namespace P2PVR {
+template<typename T>
+T *
+get_pointer(const IceInternal::Handle<T> & t) BOOST_NOEXCEPT
+{
+	return t.get();
+}
+
+class DLL_PRIVATE OpenTuner {
+	public:
+		OpenTuner(DVBSI::DeliveryPtr, TunerPtr);
+
+		const DVBSI::DeliveryPtr delivery;
+		const TunerPtr tuner;
+
+		unsigned int clients;
+};
+
+DevicesI::Options::Options() :
+	IceTray::Options("P2PVR Devices")
+{
+}
+
+ICETRAY_OPTIONS(DevicesI::Options,
+		("p2pvr.localdevices.frontend", boost::program_options::value(&devices), "Frontend of DVB device(s) to use (/dev/dvb/adapterX/frontendY)")
+);
+
+IceTray::Logging::LoggerPtr DevicesI::logger(LOGMANAGER()->getLogger<DevicesI>());
+
+DevicesI::DevicesI()
+{
+	devices = options->devices;
+	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+}
+
+DevicesI::~DevicesI()
+{
+	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+}
+
+TunerPtr
+DevicesI::getTuner()
+{
+	if (devices.empty()) {
+		throw NoSuitableDeviceAvailable();
+	}
+	for (auto devItr = devices.begin(); devItr != devices.end(); devItr++) {
+		try {
+			return new DVB::TunerI(*devItr);
+		}
+		catch (...) {
+			logger->messagebf(LOG::DEBUG, "%s: Failed to open device %s", __PRETTY_FUNCTION__,
+					*devItr);
+		}
+	}
+	throw NoSuitableDeviceAvailable();
+}
+
+TunerPtr
+DevicesI::getTuner(const DVBSI::DeliveryPtr & delivery)
+{
+	logger->messagebf(LOG::DEBUG, "%s: Searching for an open sharable tuner (frequency %d)", __PRETTY_FUNCTION__, delivery->Frequency);
+	Lock(lock);
+	// Check for an already open tuner which is correctly tuned.
+	auto existingItr = openDevices.find(delivery->TransportStreamId);
+	if (existingItr != openDevices.end()) {
+		existingItr->second->clients += 1;
+		return existingItr->second->tuner;
+	}
+	// Open a tuner and tune it as required.
+	if (devices.empty()) {
+		throw NoSuitableDeviceAvailable();
+	}
+	for (auto devItr = devices.begin(); devItr != devices.end(); devItr++) {
+		try {
+			TunerPtr tuner = new DVB::TunerI(*devItr);
+			tuner->TuneTo(delivery);
+			openDevices.insert({ delivery->TransportStreamId, OpenTunerPtr(new OpenTuner(delivery, tuner)) });
+			devices.erase(devItr);
+			return tuner;
+		}
+		catch (...) {
+			logger->messagebf(LOG::DEBUG, "%s: Failed to open and tune device %s to frequency %d", __PRETTY_FUNCTION__,
+					*devItr, delivery->Frequency);
+		}
+	}
+	logger->messagebf(LOG::DEBUG, "%s: Failed to open and tune any device to frequency %d", __PRETTY_FUNCTION__,
+			delivery->Frequency);
+	throw NoSuitableDeviceAvailable();
+}
+
+TunerPtr
+DevicesI::getTuner(const DeliveryProvider & provider)
+{
+	ScopeLock(lock) {
+		if (!openDevices.empty()) {
+			auto openDevice = openDevices.begin()->second;
+			openDevice->clients++;
+			return openDevice->tuner;
+		}
+
+	}
+	return getTuner(provider());
+}
+
+void
+DevicesI::releaseTuner(const TunerPtr & tuner)
+{
+	Lock(lock);
+	logger->messagebf(LOG::DEBUG, "%s", __PRETTY_FUNCTION__);
+	auto openTuner = std::find_if(openDevices.begin(), openDevices.end(), [&tuner](const auto & ot) {
+			return ot.second->tuner == tuner;
+		});
+	if (openTuner == openDevices.end()) {
+		logger->messagebf(LOG::DEBUG, "%s: Not one of mine", __PRETTY_FUNCTION__);
+		throw DeviceError();
+	}
+	logger->messagebf(LOG::DEBUG, "%s: Locally owned deivce %s", __PRETTY_FUNCTION__, openTuner->first);
+	openTuner->second->clients -= 1;
+	if (openTuner->second->clients == 0) {
+		openDevices.erase(openTuner);
+		devices.push_back(openTuner->second->tuner->GetDevice());
+	}
+}
+
+void
+DevicesI::Scan(const std::string &, const Ice::Current &)
+{
+	Lock(lock);
+}
+
+void
+DevicesI::Add(const std::string & frontend, const Ice::Current &)
+{
+	Lock(lock);
+	devices.push_back(frontend);
+}
+
+void
+DevicesI::Remove(const std::string & frontend, const Ice::Current &)
+{
+	Lock(lock);
+	devices.erase(std::remove(devices.begin(), devices.end(), frontend), devices.end());
+}
+
+::Ice::Int
+DevicesI::TunerCount(const Ice::Current &)
+{
+	Lock(lock);
+	return devices.size() + openDevices.size();
+}
+
+OpenTuner::OpenTuner(DVBSI::DeliveryPtr d, TunerPtr t) :
+	delivery(d),
+	tuner(t),
+	clients(1)
+{
+}
+
+void
+DevicesI::finiteTunerOperation(TunerPtr && tuner, const Target & target)
+{
+	try {
+		target(tuner);
+		releaseTuner(tuner);
+	}
+	catch (...) {
+		releaseTuner(tuner);
+		throw;
+	}
+}
+
+void
+DevicesI::ScanAndSendNetworkInformation(const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(), boost::bind(&Tuner::ScanAndSendNetworkInformation, _1, target));
+}
+
+void
+DevicesI::SendNetworkInformation(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendNetworkInformation, _1, target));
+}
+
+void
+DevicesI::SendBouquetAssociations(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current &)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendBouquetAssociations, _1, target));
+}
+
+void
+DevicesI::SendServiceDescriptions(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendServiceDescriptions, _1, target));
+}
+
+void
+DevicesI::SendProgramAssociationTable(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendProgramAssociationTable, _1, target));
+}
+
+void
+DevicesI::SendProgramMap(const ::DVBSI::DeliveryPtr & del, ::Ice::Int pids, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendProgramMap, _1, pids, target));
+}
+
+void
+DevicesI::SendEventInformation(const ::DVBSI::DeliveryPtr & del, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	finiteTunerOperation(getTuner(del), boost::bind(&Tuner::SendEventInformation, _1, target));
+}
+
+::Ice::Int
+DevicesI::StartSendingTS(const ::DVBSI::DeliveryPtr & del, const PacketIds & pids, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	auto tuner = getTuner(del);
+	try {
+		return backgroundOperations.insert({ tuner->StartSendingTS(pids, target), tuner }).first->first;
+	}
+	catch (...) {
+		releaseTuner(tuner);
+		throw;
+	}
+}
+
+::Ice::Int
+DevicesI::StartSendingSection(const ::DVBSI::DeliveryPtr & del, ::Ice::Int sid, const RawDataClientPrx & target, const ::Ice::Current&)
+{
+	auto tuner = getTuner(del);
+	try {
+		return backgroundOperations.insert({ tuner->StartSendingSection(sid, target), tuner }).first->first;
+	}
+	catch (...) {
+		releaseTuner(tuner);
+		throw;
+	}
+}
+
+void
+DevicesI::StopSending(::Ice::Int handle, const ::Ice::Current&)
+{
+	auto tunerItr = backgroundOperations.find(handle);
+	if (tunerItr != backgroundOperations.end()) {
+		tunerItr->second->StopSending(handle);
+		backgroundOperations.erase(handle);
+	}
+}
+
+}
+
diff --git a/p2pvr/devices/devices.h b/p2pvr/devices/devices.h
new file mode 100644
index 0000000..0d8af11
--- /dev/null
+++ b/p2pvr/devices/devices.h
@@ -0,0 +1,69 @@
+#ifndef LOCALDEVICES_H
+#define LOCALDEVICES_H
+
+// Local devices implements a device collection (Devices) for any devices physically
+// attached to the local machine; that is, can be accessed directly through /dev/dvb/adapterX
+
+#include <dvb.h>
+#include <options.h>
+#include <mutex>
+#include <visibility.h>
+#include <logger.h>
+#include <boost/filesystem/path.hpp>
+
+namespace P2PVR {
+class OpenTuner;
+class DLL_PUBLIC DevicesI : public Tuners {
+	public:
+		class Options : public IceTray::Options {
+			public:
+				Options();
+
+				ICETRAY_OPTIONS_DECLARE;
+
+				std::vector<boost::filesystem::path> devices;
+		};
+
+		DevicesI();
+		~DevicesI();
+
+    virtual void ScanAndSendNetworkInformation(const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendNetworkInformation(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendBouquetAssociations(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendServiceDescriptions(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendProgramAssociationTable(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendProgramMap(const ::DVBSI::DeliveryPtr&, ::Ice::Int, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void SendEventInformation(const ::DVBSI::DeliveryPtr&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual ::Ice::Int StartSendingTS(const ::DVBSI::DeliveryPtr&, const PacketIds&, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual ::Ice::Int StartSendingSection(const ::DVBSI::DeliveryPtr&, ::Ice::Int, const RawDataClientPrx&, const ::Ice::Current&) override;
+    virtual void StopSending(::Ice::Int, const ::Ice::Current&) override;
+
+		void Scan(const std::string & path, const Ice::Current &) override;
+		void Add(const std::string & frontend, const Ice::Current &) override;
+		void Remove(const std::string & frontend, const Ice::Current &) override;
+		::Ice::Int TunerCount(const Ice::Current &) override;
+
+	private:
+		typedef boost::function<DVBSI::DeliveryPtr()> DeliveryProvider;
+		TunerPtr getTuner();
+		TunerPtr getTuner(const DeliveryProvider &);
+		TunerPtr getTuner(const DVBSI::DeliveryPtr &);
+		void releaseTuner(const TunerPtr &);
+
+		typedef boost::function<void(TunerPtr)> Target;
+		void finiteTunerOperation(TunerPtr && tuner, const Target &);
+
+		typedef boost::shared_ptr<OpenTuner> OpenTunerPtr;
+		typedef std::map<Ice::Int, OpenTunerPtr> OpenDevices;
+		OpenDevices openDevices;
+		typedef std::map<Ice::Int, TunerPtr> BackgroundOperations;
+		BackgroundOperations backgroundOperations;
+		std::vector<boost::filesystem::path> devices;
+		std::mutex lock;
+		static IceTray::Logging::LoggerPtr logger;
+		IceTray::OptionsResolver<Options> options;
+};
+}
+
+#endif
+
diff --git a/p2pvr/devices/frontend.cpp b/p2pvr/devices/frontend.cpp
index c6f258b..1026a20 100644
--- a/p2pvr/devices/frontend.cpp
+++ b/p2pvr/devices/frontend.cpp
@@ -6,7 +6,7 @@
 
 namespace P2PVR {
 namespace DVB {
-Frontend::Frontend(Tuner * t, const struct dvb_frontend_info & i, IceTray::Logging::LoggerPtr log) :
+Frontend::Frontend(TunerI * t, const struct dvb_frontend_info & i, IceTray::Logging::LoggerPtr log) :
 	tuner(t),
 	fe_info(i),
 	logger(log)
@@ -28,8 +28,8 @@ Frontend::GetStatus() const
 {
 	fe_status_t status;
 	if (ioctl(tuner->frontendFD, FE_READ_STATUS, &status) < 0) {
-		logger->messagebf(LOG::ERR, "Reading frontend %s status failed (%s:%d)", tuner->Device(), strerror(errno), errno);
-		throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno);
+		logger->messagebf(LOG::ERR, "Reading frontend %s status failed (%s:%d)", tuner->GetDevice(), strerror(errno), errno);
+		throw P2PVR::DeviceError(tuner->GetDevice(), strerror(errno), errno);
 	}
 	return status;
 }
@@ -42,5 +42,5 @@ Frontend::FactoryKey(fe_type t)
 
 }
 }
-INSTANTIATEFACTORY(P2PVR::DVB::Frontend, P2PVR::DVB::Tuner *, const struct dvb_frontend_info &);
+INSTANTIATEFACTORY(P2PVR::DVB::Frontend, P2PVR::DVB::TunerI *, const struct dvb_frontend_info &);
 
diff --git a/p2pvr/devices/frontend.h b/p2pvr/devices/frontend.h
index 4e47c10..63b000d 100644
--- a/p2pvr/devices/frontend.h
+++ b/p2pvr/devices/frontend.h
@@ -8,12 +8,12 @@
 
 namespace P2PVR {
 namespace DVB {
-class Tuner;
+class TunerI;
 
 class Frontend {
 	public:
 		typedef boost::function<bool(long)> OnFrequencyFound;
-		Frontend(Tuner *, const struct dvb_frontend_info &, IceTray::Logging::LoggerPtr);
+		Frontend(TunerI *, const struct dvb_frontend_info &, IceTray::Logging::LoggerPtr);
 		virtual ~Frontend();
 
 		fe_status_t GetStatus() const;
@@ -25,12 +25,12 @@ class Frontend {
 		static std::string FactoryKey(fe_type);
 
 	protected:
-		const Tuner * tuner;
+		TunerI * const tuner;
 		const struct dvb_frontend_info fe_info;
 		IceTray::Logging::LoggerPtr logger;
 };
 
-typedef AdHoc::Factory<Frontend, Tuner *, const struct dvb_frontend_info &> FrontendFactory;
+typedef AdHoc::Factory<Frontend, TunerI *, const struct dvb_frontend_info &> FrontendFactory;
 typedef boost::shared_ptr<Frontend> FrontendPtr;
 }
 }
diff --git a/p2pvr/devices/frontends/ofdm.cpp b/p2pvr/devices/frontends/ofdm.cpp
index 991996d..e6c3979 100644
--- a/p2pvr/devices/frontends/ofdm.cpp
+++ b/p2pvr/devices/frontends/ofdm.cpp
@@ -11,7 +11,7 @@ namespace DVB {
 namespace Frontends {
 class OFDM : public Frontend {
 	public:
-		OFDM(Tuner * t, const struct dvb_frontend_info & i) :
+		OFDM(TunerI * t, const struct dvb_frontend_info & i) :
 			Frontend(t, i, LOGMANAGER()->getLogger<OFDM>())
 		{
 		}
@@ -42,8 +42,8 @@ class OFDM : public Frontend {
 			dvb_frontend_parameters feparams;
 			memset(&feparams, 0, sizeof(dvb_frontend_parameters));
 			if (ioctl(tuner->frontendFD, FE_GET_FRONTEND, &feparams) < 0) {
-				logger->messagebf(LOG::ERR, "Reading frontend parameters failed (%s:%d)", tuner->Device(), strerror(errno), errno);
-				throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno);
+				logger->messagebf(LOG::ERR, "Reading frontend parameters failed (%s:%d)", tuner->GetDevice(), strerror(errno), errno);
+				throw P2PVR::DeviceError(tuner->GetDevice(), strerror(errno), errno);
 			}
 			return feparams;
 		}
@@ -57,24 +57,24 @@ class OFDM : public Frontend {
 			}
 			// Was it useful?
 			if (!(status & (FE_HAS_SIGNAL | FE_HAS_CARRIER))) {
-				logger->messagebf(LOG::ERR, "Tuning of device %s failed (No signal or carrier: 0x%02x)", tuner->Device(), status);
-				throw P2PVR::DeviceError(tuner->Device(), "No carrier", 0);
+				logger->messagebf(LOG::ERR, "Tuning of device %s failed (No signal or carrier: 0x%02x)", tuner->GetDevice(), status);
+				throw P2PVR::DeviceError(tuner->GetDevice(), "No carrier", 0);
 			}
 			// Wait for lock
 			for (int x = tuner->options->LockTimeout / 10; x > 0 && ((status = GetStatus()) & FE_HAS_LOCK) == 0; x -= 1) {
 				usleep(10000);
 			}
 			if (!(status & FE_HAS_LOCK)) {
-				logger->messagebf(LOG::ERR, "Tuning of device %s failed (%s)", tuner->Device(), "No lock");
-				throw P2PVR::DeviceError(tuner->Device(), "No lock", 0);
+				logger->messagebf(LOG::ERR, "Tuning of device %s failed (%s)", tuner->GetDevice(), "No lock");
+				throw P2PVR::DeviceError(tuner->GetDevice(), "No lock", 0);
 			}
 		}
 
 		void SetParameters(const dvb_frontend_parameters & feparams) const
 		{
 			if (ioctl(tuner->frontendFD, FE_SET_FRONTEND, &feparams) < 0) {
-				logger->messagebf(LOG::ERR, "Tuning of device %s failed (%s:%d)", tuner->Device(), strerror(errno), errno);
-				throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno);
+				logger->messagebf(LOG::ERR, "Tuning of device %s failed (%s:%d)", tuner->GetDevice(), strerror(errno), errno);
+				throw P2PVR::DeviceError(tuner->GetDevice(), strerror(errno), errno);
 			}
 		}
 
diff --git a/p2pvr/devices/localDevices.cpp b/p2pvr/devices/localDevices.cpp
deleted file mode 100644
index ac13a29..0000000
--- a/p2pvr/devices/localDevices.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-#include "localDevices.h"
-#include <Ice/Ice.h>
-#include "tuner.h"
-#include "bindTimerTask.h"
-
-namespace P2PVR {
-LocalDevicesI::Devices LocalDevicesI::devices;
-std::mutex LocalDevicesI::lock;
-
-LocalDevicesI::Options::Options() :
-	IceTray::Options("P2PVR Devices")
-{
-}
-
-ICETRAY_OPTIONS(LocalDevicesI::Options,
-		("p2pvr.localdevices.frontend", boost::program_options::value(&devices), "Frontend of DVB device(s) to use (/dev/dvb/adapterX/frontendY)")
-);
-
-IceTray::Logging::LoggerPtr LocalDevicesI::logger(LOGMANAGER()->getLogger<LocalDevicesI>());
-
-LocalDevicesI::LocalDevicesI(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr t) :
-	timer(t),
-	clientCheck(new BindTimerTask(boost::bind(&LocalDevicesI::ClientCheck, this, adapter)))
-{
-	for (auto & device : options->devices) {
-		devices.insert({ device, nullptr });
-	}
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
-	timer->scheduleRepeated(clientCheck, IceUtil::Time::seconds(30));
-}
-
-LocalDevicesI::~LocalDevicesI()
-{
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
-	timer->cancel(clientCheck);
-}
-
-void
-LocalDevicesI::ClientCheck(Ice::ObjectAdapterPtr adapter)
-{
-	std::lock_guard<std::mutex> g(lock);
-	for (auto & device : devices) {
-		if (device.second && device.second->tuner->GetLastUsedTime() < time(NULL) - 30) {
-			logger->messagebf(LOG::DEBUG, "%s: Device %s no longer in use", __PRETTY_FUNCTION__, device.first);
-			auto id = device.second->tuner->ice_getIdentity();
-			if (adapter->find(id)) {
-				adapter->remove(id);
-			}
-			device.second.reset();
-		}
-	}
-}
-
-TunerPrx
-LocalDevicesI::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
-{
-	std::lock_guard<std::mutex> g(lock);
-	logger->messagebf(LOG::DEBUG, "%s: Searching for an open sharable tuner (frequency %d)", __PRETTY_FUNCTION__, delivery->Frequency);
-	auto openTuner = std::find_if(devices.begin(), devices.end(), [delivery](const Devices::value_type & ot) {
-			return ot.second && !ot.second->openedPrivate && ot.second->delivery && ot.second->delivery->Frequency == delivery->Frequency;
-		});
-	if (openTuner != devices.end()) {
-		openTuner->second->clients += 1;
-		return openTuner->second->tuner;
-	}
-
-	openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; });
-	if (openTuner == devices.end()) {
-		logger->messagebf(LOG::DEBUG, "%s: None suitable and none free (frequency %d)",
-				__PRETTY_FUNCTION__, delivery->Frequency);
-		throw NoSuitableDeviceAvailable();
-	}
-
-	logger->messagebf(LOG::DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)",
-			__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
-	PrivateTunerPtr t = new DVB::Tuner(openTuner->first);
-	t->TuneTo(delivery, ice);
-	auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
-	openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, false));
-
-	logger->messagebf(LOG::DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)",
-			__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
-	return tuner;
-}
-
-TunerPrx
-LocalDevicesI::GetTunerAny(const DVBSI::DeliveryPtr & delivery, const Ice::Current & ice)
-{
-	std::lock_guard<std::mutex> g(lock);
-	logger->messagebf(LOG::DEBUG, "%s: Searching for an open sharable tuner any frequency", __PRETTY_FUNCTION__);
-	auto openTuner = std::find_if(devices.begin(), devices.end(), [delivery](const Devices::value_type & ot) {
-			return ot.second && !ot.second->openedPrivate && ot.second->delivery;
-		});
-	if (openTuner != devices.end()) {
-		openTuner->second->clients += 1;
-		return openTuner->second->tuner;
-	}
-
-	openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; });
-	if (openTuner == devices.end()) {
-		logger->messagebf(LOG::DEBUG, "%s: None suitable and none free (frequency %d)",
-				__PRETTY_FUNCTION__, delivery->Frequency);
-		throw NoSuitableDeviceAvailable();
-	}
-
-	logger->messagebf(LOG::DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)",
-			__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
-	PrivateTunerPtr t = new DVB::Tuner(openTuner->first);
-	t->TuneTo(delivery, ice);
-	auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(t));
-	openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, false));
-
-	logger->messagebf(LOG::DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)",
-			__PRETTY_FUNCTION__, delivery->Frequency, openTuner->first);
-	return tuner;
-}
-
-PrivateTunerPrx
-LocalDevicesI::GetPrivateTuner(short , const Ice::Current & ice)
-{
-	std::lock_guard<std::mutex> g(lock);
-	logger->messagebf(LOG::DEBUG, "%s: Opening a private tuner", __PRETTY_FUNCTION__);
-	auto openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; });
-	if (openTuner == devices.end()) {
-		logger->messagebf(LOG::DEBUG, "%s: None free", __PRETTY_FUNCTION__);
-		throw NoSuitableDeviceAvailable();
-	}
-
-	logger->messagebf(LOG::DEBUG, "%s: Opening a private tuner (frontend %s)",
-			__PRETTY_FUNCTION__, openTuner->first);
-	auto tuner = PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new DVB::Tuner(openTuner->first)));
-	openTuner->second = OpenTunerPtr(new OpenTuner(NULL, tuner, true));
-
-	return tuner;
-}
-
-void
-LocalDevicesI::ReleaseTuner(const TunerPrx & tuner, const Ice::Current & ice)
-{
-	std::lock_guard<std::mutex> g(lock);
-	logger->messagebf(LOG::DEBUG, "%s", __PRETTY_FUNCTION__);
-	auto openTuner = std::find_if(devices.begin(), devices.end(), [tuner](const Devices::value_type & ot) {
-			return ot.second && ot.second->tuner == tuner;
-		});
-	if (openTuner == devices.end()) {
-		logger->messagebf(LOG::DEBUG, "%s: Not one of mine", __PRETTY_FUNCTION__);
-		return;
-	}
-	logger->messagebf(LOG::DEBUG, "%s: Locally owned deivce %s", __PRETTY_FUNCTION__, openTuner->first);
-	openTuner->second->clients -= 1;
-	if (openTuner->second->clients == 0) {
-		auto id = tuner->ice_getIdentity();
-		if (ice.adapter->find(id)) {
-			ice.adapter->remove(id);
-		}
-		openTuner->second.reset();
-	}
-}
-
-int
-LocalDevicesI::TunerCount(const Ice::Current &)
-{
-	std::lock_guard<std::mutex> g(lock);
-	return devices.size();
-}
-
-void
-LocalDevicesI::Scan(const Ice::Current &)
-{
-	std::lock_guard<std::mutex> g(lock);
-}
-
-void
-LocalDevicesI::Add(const std::string & frontend, const Ice::Current &)
-{
-	std::lock_guard<std::mutex> g(lock);
-	devices.insert(Devices::value_type(frontend, OpenTunerPtr()));
-}
-
-void
-LocalDevicesI::Remove(const std::string & frontend, const Ice::Current &)
-{
-	std::lock_guard<std::mutex> g(lock);
-	devices.erase(frontend);
-}
-
-LocalDevicesI::OpenTuner::OpenTuner(DVBSI::DeliveryPtr d, PrivateTunerPrx t, bool op) :
-	openedPrivate(op),
-	delivery(d),
-	tuner(t),
-	clients(1)
-{
-}
-}
-
diff --git a/p2pvr/devices/localDevices.h b/p2pvr/devices/localDevices.h
deleted file mode 100644
index 0fd4ad2..0000000
--- a/p2pvr/devices/localDevices.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#ifndef LOCALDEVICES_H
-#define LOCALDEVICES_H
-
-// Local devices implements a device collection (Devices) for any devices physically
-// attached to the local machine; that is, can be accessed directly through /dev/dvb/adapterX
-
-#include <dvb.h>
-#include <options.h>
-#include <mutex>
-#include <visibility.h>
-#include <IceUtil/Timer.h>
-#include <logger.h>
-
-namespace P2PVR {
-class DLL_PUBLIC LocalDevicesI : public LocalDevices {
-	public:
-		class Options : public IceTray::Options {
-			public:
-				Options();
-
-				ICETRAY_OPTIONS_DECLARE;
-
-				std::vector<std::string> devices;
-		};
-
-		LocalDevicesI(Ice::ObjectAdapterPtr adapter, IceUtil::TimerPtr);
-		~LocalDevicesI();
-
-		TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, const Ice::Current &);
-		TunerPrx GetTunerAny(const DVBSI::DeliveryPtr &, const Ice::Current &);
-		PrivateTunerPrx GetPrivateTuner(short type, const Ice::Current &);
-		void ReleaseTuner(const TunerPrx &, const Ice::Current &);
-		int TunerCount(const Ice::Current &);
-
-		void Scan(const Ice::Current &);
-		void Add(const std::string & frontend, const Ice::Current &);
-		void Remove(const std::string & frontend, const Ice::Current &);
-
-	private:
-		// Reference to global timer
-		IceUtil::TimerPtr timer;
-		IceUtil::TimerTaskPtr clientCheck;
-
-		// Check that registered clients haven't silently gone away
-		DLL_PRIVATE void ClientCheck(Ice::ObjectAdapterPtr adapter);
-
-		class DLL_PRIVATE OpenTuner {
-			public:
-				OpenTuner(DVBSI::DeliveryPtr, PrivateTunerPrx, bool);
-
-				const bool openedPrivate;
-				const DVBSI::DeliveryPtr delivery;
-				const PrivateTunerPrx tuner;
-
-				unsigned int clients;
-		};
-		typedef boost::shared_ptr<OpenTuner> OpenTunerPtr;
-		typedef std::map<std::string, OpenTunerPtr> Devices;
-		static Devices devices;
-		static std::mutex lock;
-		static IceTray::Logging::LoggerPtr logger;
-		IceTray::OptionsResolver<Options> options;
-};
-}
-
-#endif
-
diff --git a/p2pvr/devices/mockTuner.cpp b/p2pvr/devices/mockTuner.cpp
index 4430bc4..1316b6d 100644
--- a/p2pvr/devices/mockTuner.cpp
+++ b/p2pvr/devices/mockTuner.cpp
@@ -31,6 +31,7 @@ ResourceFile(pmt);
 ResourceFile(vid);
 
 int MockTuner::eventSet = 0;
+int MockTuner::senderId = 1;
 
 IceTray::Logging::LoggerPtr MockTuner::logger = LOGMANAGER()->getLogger<MockTuner>();
 
@@ -40,16 +41,21 @@ MockTuner::SetEventsSet(int n)
 	eventSet = n;
 }
 
-MockTuner::MockTuner() :
-	senderId(1)
+MockTuner::MockTuner(Ice::CommunicatorPtr c) :
+	ic(c)
 {
 }
 
-void MockTuner::TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&)
+void MockTuner::TuneTo(const DVBSI::DeliveryPtr &)
 {
 }
 
-int MockTuner::GetStatus(const Ice::Current&)
+int MockTuner::GetStatus()
+{
+	return 0;
+}
+
+std::string MockTuner::GetDevice()
 {
 	return 0;
 }
@@ -80,11 +86,11 @@ Ice::ByteSeq MockTuner::Decompress(const Ice::ByteSeq & dataxz)
 	return data;
 }
 
-void MockTuner::DecompressAndSendPackets(const Ice::ByteSeq & dataxz, const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) const
+void MockTuner::DecompressAndSendPackets(const Ice::ByteSeq & dataxz, const P2PVR::RawDataClientPrx & client) const
 {
 	logger->messagebf(LOG::DEBUG, "%s: deserialize", __PRETTY_FUNCTION__);
 	std::list<Ice::ByteSeq> packets;
-	auto istrm = Ice::createInputStream(ice.adapter->getCommunicator(), Decompress(dataxz));
+	auto istrm = Ice::createInputStream(ic, Decompress(dataxz));
 	istrm->read(packets);
 
 	logger->messagebf(LOG::DEBUG, "%s: send", __PRETTY_FUNCTION__);
@@ -95,42 +101,42 @@ void MockTuner::DecompressAndSendPackets(const Ice::ByteSeq & dataxz, const P2PV
 	logger->messagebf(LOG::DEBUG, "%s: complete", __PRETTY_FUNCTION__);
 }
 
-void MockTuner::ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+void MockTuner::ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client)
 {
-	DecompressAndSendPackets(network, client, ice);
+	DecompressAndSendPackets(network, client);
 }
 
-void MockTuner::SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+void MockTuner::SendNetworkInformation(const P2PVR::RawDataClientPrx & client)
 {
-	DecompressAndSendPackets(network, client, ice);
+	DecompressAndSendPackets(network, client);
 }
 
-void MockTuner::SendBouquetAssociations(const P2PVR::RawDataClientPrx &, const Ice::Current&)
+void MockTuner::SendBouquetAssociations(const P2PVR::RawDataClientPrx &)
 {
 }
 
-void MockTuner::SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+void MockTuner::SendServiceDescriptions(const P2PVR::RawDataClientPrx & client)
 {
-	DecompressAndSendPackets(services, client, ice);
+	DecompressAndSendPackets(services, client);
 }
 
-void MockTuner::SendProgramMap(Ice::Int, const P2PVR::RawDataClientPrx &, const Ice::Current&)
+void MockTuner::SendProgramMap(Ice::Int, const P2PVR::RawDataClientPrx &)
 {
 }
 
-void MockTuner::SendProgramAssociationTable(const P2PVR::RawDataClientPrx &, const Ice::Current&)
+void MockTuner::SendProgramAssociationTable(const P2PVR::RawDataClientPrx &)
 {
 }
 
-void MockTuner::SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice)
+void MockTuner::SendEventInformation(const P2PVR::RawDataClientPrx & client)
 {
-	DecompressAndSendPackets(eventSet == 0 ? events1 : events2, client, ice);
+	DecompressAndSendPackets(eventSet == 0 ? events1 : events2, client);
 }
 
-void MockTuner::SendLoop(const P2PVR::RawDataClientPrx & t, const Ice::ByteSeq & dataxz, const Ice::Current & ice) const
+void MockTuner::SendLoop(const P2PVR::RawDataClientPrx & t, const Ice::ByteSeq & dataxz) const
 {
 	std::list<Ice::ByteSeq> packets;
-	auto istrm = Ice::createInputStream(ice.adapter->getCommunicator(), Decompress(dataxz));
+	auto istrm = Ice::createInputStream(ic, Decompress(dataxz));
 	istrm->read(packets);
 	logger->messagebf(LOG::DEBUG, "%s: loop over %d packets", __PRETTY_FUNCTION__, packets.size());
 	auto p = packets.begin();
@@ -149,23 +155,23 @@ void MockTuner::SendLoop(const P2PVR::RawDataClientPrx & t, const Ice::ByteSeq &
 }
 
 
-int MockTuner::StartSendingTS(const P2PVR::PacketIds &, const P2PVR::RawDataClientPrx & t, const Ice::Current & ice)
+int MockTuner::StartSendingTS(const P2PVR::PacketIds &, const P2PVR::RawDataClientPrx & t)
 {
-	return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, vid, ice)}).first->first;
+	return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, vid)}).first->first;
 }
 
-int MockTuner::StartSendingSection(Ice::Int sid, const P2PVR::RawDataClientPrx & t, const Ice::Current & ice)
+int MockTuner::StartSendingSection(Ice::Int sid, const P2PVR::RawDataClientPrx & t)
 {
 	switch (sid) {
 		case 0: // pat
-			return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, pat, ice)}).first->first;
+			return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, pat)}).first->first;
 		case 100: // sample pmt
-			return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, pmt, ice)}).first->first;
+			return senders.insert({senderId++, new boost::thread(&MockTuner::SendLoop, this, t, pmt)}).first->first;
 	}
 	throw std::runtime_error("I don't have a sample for that");
 }
 
-void MockTuner::StopSending(int s, const Ice::Current &)
+void MockTuner::StopSending(int s)
 {
 	logger->messagebf(LOG::DEBUG, "%s: stop %d", __PRETTY_FUNCTION__, s);
 	auto sitr = senders.find(s);
@@ -175,11 +181,6 @@ void MockTuner::StopSending(int s, const Ice::Current &)
 		senders.erase(sitr);
 	}
 }
-
-Ice::Long MockTuner::GetLastUsedTime(const Ice::Current&)
-{
-	return time(NULL);
-}
 }
 }
 
diff --git a/p2pvr/devices/mockTuner.h b/p2pvr/devices/mockTuner.h
index 73ab27c..d0db11e 100644
--- a/p2pvr/devices/mockTuner.h
+++ b/p2pvr/devices/mockTuner.h
@@ -9,38 +9,38 @@
 
 namespace P2PVR {
 namespace Testing {
-class DLL_PUBLIC MockTuner : public PrivateTuner {
+class DLL_PUBLIC MockTuner : public Tuner {
 	public:
-		MockTuner();
+		MockTuner(Ice::CommunicatorPtr);
 
-		void TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&);
-		int GetStatus(const Ice::Current&);
+		void TuneTo(const DVBSI::DeliveryPtr &) override;
+		int GetStatus() override;
+		std::string GetDevice() override;
 
-		void ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
-		void SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
-		void SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current&);
-		void SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current&);
-		void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current&);
-		void SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current&);
-		void SendEventInformation(const RawDataClientPrx & client, const Ice::Current&);
+		void ScanAndSendNetworkInformation(const RawDataClientPrx & client) override;
+		void SendNetworkInformation(const RawDataClientPrx & client) override;
+		void SendBouquetAssociations(const RawDataClientPrx & client) override;
+		void SendServiceDescriptions(const RawDataClientPrx & client) override;
+		void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client) override;
+		void SendProgramAssociationTable(const RawDataClientPrx & client) override;
+		void SendEventInformation(const RawDataClientPrx & client) override;
 
-		int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current &);
-		int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current &);
-		void StopSending(int handle, const Ice::Current &);
-
-		Ice::Long GetLastUsedTime(const Ice::Current&);
+		int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client) override;
+		int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client) override;
+		void StopSending(int handle) override;
 
 		static void SetEventsSet(int n);
 
 	protected:
 		static Ice::ByteSeq Decompress(const Ice::ByteSeq &);
 		static void LZMA_ASSERT(int ret_xz);
-		void DecompressAndSendPackets(const Ice::ByteSeq &, const RawDataClientPrx &, const Ice::Current&) const;
-		void SendLoop(const RawDataClientPrx & t, const Ice::ByteSeq & dataxz, const Ice::Current & ice) const;
+		void DecompressAndSendPackets(const Ice::ByteSeq &, const RawDataClientPrx &) const;
+		void SendLoop(const RawDataClientPrx & t, const Ice::ByteSeq & dataxz) const;
 
 		static int eventSet;
 		std::map<int, boost::thread *> senders;
-		int senderId;
+		static int senderId;
+		Ice::CommunicatorPtr ic;
 
 		static IceTray::Logging::LoggerPtr logger;
 };
diff --git a/p2pvr/devices/tuner.cpp b/p2pvr/devices/tuner.cpp
index 73dcd67..bb27a44 100644
--- a/p2pvr/devices/tuner.cpp
+++ b/p2pvr/devices/tuner.cpp
@@ -8,19 +8,19 @@
 #include <linux/dvb/dmx.h>
 #include <boost/tuple/tuple.hpp>
 #include <cxxabi.h>
+#include <lockHelpers.h>
 #include "tunerSendSi.h"
 #include "tunerSendTs.h"
 
 namespace P2PVR {
 namespace DVB {
-IceTray::Logging::LoggerPtr Tuner::logger = LOGMANAGER()->getLogger<Tuner>();
+IceTray::Logging::LoggerPtr TunerI::logger = LOGMANAGER()->getLogger<TunerI>();
 
-Tuner::Tuner(const boost::filesystem::path & df) :
+TunerI::TunerI(const boost::filesystem::path & df) :
 	deviceFrontend(df),
 	deviceRoot(df.branch_path()),
 	frontendFD(deviceFrontend, O_RDWR),
-	backgroundThread(NULL),
-	lastUsedTime(time(NULL))
+	backgroundThread(NULL)
 {
 	struct dvb_frontend_info fe_info;
 	if (ioctl(frontendFD, FE_GET_INFO, &fe_info) < 0) {
@@ -31,7 +31,7 @@ Tuner::Tuner(const boost::filesystem::path & df) :
 			deviceRoot, frontend->Info().name, frontend->Type());
 }
 
-Tuner::~Tuner()
+TunerI::~TunerI()
 {
 	{
 		std::lock_guard<std::mutex> g(lock);
@@ -47,27 +47,25 @@ Tuner::~Tuner()
 }
 
 void
-Tuner::TuneTo(const DVBSI::DeliveryPtr & mp, const Ice::Current&)
+TunerI::TuneTo(const DVBSI::DeliveryPtr & mp)
 {
 	frontend->TuneTo(mp);
 }
 
 int
-Tuner::GetStatus(const Ice::Current &)
+TunerI::GetStatus()
 {
-	time(&lastUsedTime);
 	return frontend->GetStatus();
 }
 
 std::string
-Tuner::Device() const
+TunerI::GetDevice()
 {
-	time(&lastUsedTime);
 	return deviceRoot.string();
 }
 
 int
-Tuner::OpenDemux() const
+TunerI::OpenDemux() const
 {
 	int demux = open((deviceRoot / "demux0").string().c_str(), O_RDWR | O_NONBLOCK);
 	if (demux < 0) {
@@ -77,12 +75,11 @@ Tuner::OpenDemux() const
 }
 
 void
-Tuner::ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::ScanAndSendNetworkInformation(const RawDataClientPrx & client)
 {
-	time(&lastUsedTime);
-	frontend->FrequencyScan([this, &client, &ice](long) {
+	frontend->FrequencyScan([this, &client](long) {
 			try {
-				return (SendPID(0x10, client, ice) > 0);
+				return (SendPID(0x10, client) > 0);
 			}
 			catch (const std::exception & ex) {
 				char * buf = __cxxabiv1::__cxa_demangle(typeid(ex).name(), NULL, NULL, NULL);
@@ -98,57 +95,53 @@ Tuner::ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice:
 }
 
 void
-Tuner::SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendNetworkInformation(const RawDataClientPrx & client)
 {
-	SendPID(0x10, client, ice);
+	SendPID(0x10, client);
 }
 
 void
-Tuner::SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendBouquetAssociations(const RawDataClientPrx & client)
 {
-	SendPID(0x11, client, ice);
+	SendPID(0x11, client);
 }
 
 void
-Tuner::SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendServiceDescriptions(const RawDataClientPrx & client)
 {
-	SendPID(0x11, client, ice);
+	SendPID(0x11, client);
 }
 
 void
-Tuner::SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendProgramMap(Ice::Int pid, const RawDataClientPrx & client)
 {
-	SendPID(pid, client, ice);
+	SendPID(pid, client);
 }
 
 void
-Tuner::SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendProgramAssociationTable(const RawDataClientPrx & client)
 {
-	SendPID(0x00, client, ice);
+	SendPID(0x00, client);
 }
 
 void
-Tuner::SendEventInformation(const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::SendEventInformation(const RawDataClientPrx & client)
 {
-	SendPID(0x12, client, ice);
+	SendPID(0x12, client);
 }
 
 uint64_t
-Tuner::SendPID(int pid, const RawDataClientPrx & client, const Ice::Current & ice) const
+TunerI::SendPID(int pid, const RawDataClientPrx & client) const
 {
-	time(&lastUsedTime);
 	logger->messagebf(LOG::DEBUG, "%s: pid = 0x%x", __PRETTY_FUNCTION__, pid);
 
-	if (ice.con) {
-		ice.con->createProxy(client->ice_getIdentity());
-	}
 	AdHoc::FileUtils::FileHandle demux(OpenDemux());
 	RequestPID(pid, demux);
 	return ReadDemuxAndSend(demux, client);
 }
 
 void
-Tuner::RequestPID(int pid, int demux) const
+TunerI::RequestPID(int pid, int demux) const
 {
 	setBufferSize(demux, options->DemuxTableBufferSize);
 	struct dmx_sct_filter_params sctFilterParams;
@@ -162,7 +155,7 @@ Tuner::RequestPID(int pid, int demux) const
 }
 
 uint64_t
-Tuner::ReadDemuxAndSend(int demux, const RawDataClientPrx & _client) const
+TunerI::ReadDemuxAndSend(int demux, const RawDataClientPrx & _client) const
 {
 	logger->messagebf(LOG::DEBUG, "%s: begin", __PRETTY_FUNCTION__);
 	struct pollfd ufd;
@@ -194,7 +187,6 @@ Tuner::ReadDemuxAndSend(int demux, const RawDataClientPrx & _client) const
 		buf.resize(n);
 
 		client->NewData(buf);
-		time(&lastUsedTime);
 
 	} while (!client->IsFinished());
 	auto packetsSent = client->PacketsSent();
@@ -204,12 +196,11 @@ Tuner::ReadDemuxAndSend(int demux, const RawDataClientPrx & _client) const
 }
 
 int
-Tuner::StartSendingSection(int pid, const RawDataClientPrx & client, const Ice::Current &)
+TunerI::StartSendingSection(int pid, const RawDataClientPrx & client)
 {
-	time(&lastUsedTime);
 	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
 
-	std::lock_guard<std::mutex> g(lock);
+	Lock(lock);
 	int demux = backgroundClients.insert(BackgroundClients::value_type(OpenDemux(),
 				BackgroundClient(new SendSi(client)))).first->first;
 	RequestPID(pid, demux);
@@ -218,18 +209,14 @@ Tuner::StartSendingSection(int pid, const RawDataClientPrx & client, const Ice::
 }
 
 int
-Tuner::StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current & ice)
+TunerI::StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client)
 {
-	time(&lastUsedTime);
 	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
 	if (pids.empty()) {
 		throw DeviceError("demux", "Packet Id list cannot be empty", 0);
 	}
 
-	if (ice.con) {
-		ice.con->createProxy(client->ice_getIdentity());
-	}
-	std::lock_guard<std::mutex> g(lock);
+	Lock(lock);
 	int demux = backgroundClients.insert(BackgroundClients::value_type(OpenDemux(),
 				BackgroundClient(new SendTs(client)))).first->first;
 
@@ -270,7 +257,7 @@ Tuner::StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, c
 }
 
 void
-Tuner::setBufferSize(int demux, unsigned long size)
+TunerI::setBufferSize(int demux, unsigned long size)
 {
 	if (ioctl(demux, DMX_SET_BUFFER_SIZE, size)) {
 		logger->messagebf(LOG::ERR, "%s: DMX_SET_BUFFER_SIZE to %d failed (%d: %s)", __PRETTY_FUNCTION__, size, errno, strerror(errno));
@@ -280,9 +267,8 @@ Tuner::setBufferSize(int demux, unsigned long size)
 }
 
 void
-Tuner::StopSending(int handle, const Ice::Current &)
+TunerI::StopSending(int handle)
 {
-	time(&lastUsedTime);
 	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
 	std::lock_guard<std::mutex> g(lock);
 	if (backgroundClients.find(handle) != backgroundClients.end()) {
@@ -292,15 +278,15 @@ Tuner::StopSending(int handle, const Ice::Current &)
 }
 
 void
-Tuner::startSenderThread()
+TunerI::startSenderThread()
 {
 	if (!backgroundThread) {
-		backgroundThread = new std::thread(&Tuner::senderThread, this);
+		backgroundThread = new std::thread(&TunerI::senderThread, this);
 	}
 }
 
 void
-Tuner::senderThread()
+TunerI::senderThread()
 {
 	lock.lock();
 	while (!backgroundClients.empty()) {
@@ -311,7 +297,6 @@ Tuner::senderThread()
 			FD_SET(c.first, &rfds);
 		}
 		lock.unlock();
-		time(&lastUsedTime);
 
 		struct timeval tv { 2, 0 };
 		switch (select(n, &rfds, NULL, NULL, &tv)) {
@@ -361,38 +346,32 @@ Tuner::senderThread()
 	backgroundThread = NULL;
 	logger->messagebf(LOG::DEBUG, "%s: Unlocking", __PRETTY_FUNCTION__);
 	lock.unlock();
-} 
-
-Ice::Long
-Tuner::GetLastUsedTime(const Ice::Current &)
-{
-	return lastUsedTime;
 }
 
-Tuner::IDataSender::IDataSender(const RawDataClientPrx & c) :
+TunerI::IDataSender::IDataSender(const RawDataClientPrx & c) :
 	_packetsSent(0),
 	client(c)
 {
 }
 
-Tuner::IDataSender::~IDataSender()
+TunerI::IDataSender::~IDataSender()
 {
 }
 
 uint64_t
-Tuner::IDataSender::PacketsSent() const
+TunerI::IDataSender::PacketsSent() const
 {
 	return _packetsSent;
 }
 
-Tuner::Options::Options() :
+TunerI::Options::Options() :
 	IceTray::Options("P2PVR Tuner Options")
 {
 }
 
 namespace po = boost::program_options;
 
-ICETRAY_OPTIONS(Tuner::Options,
+ICETRAY_OPTIONS(TunerI::Options,
 		("p2pvr.tuner.tuningtimeout", po::value(&TuningTimeout)->default_value(500),
 		 "Timeout for a DVB frontend to tune (ms, default 500ms)")
 		("p2pvr.tuner.locktimeout", po::value(&LockTimeout)->default_value(2000),
diff --git a/p2pvr/devices/tuner.h b/p2pvr/devices/tuner.h
index b4d92b3..695b322 100644
--- a/p2pvr/devices/tuner.h
+++ b/p2pvr/devices/tuner.h
@@ -20,7 +20,7 @@ namespace Frontends {
 	class OFDM;
 }
 
-class Tuner : public PrivateTuner {
+class TunerI : public Tuner {
 	public:
 		class IDataSender {
 			public:
@@ -38,30 +38,28 @@ class Tuner : public PrivateTuner {
 		typedef boost::shared_ptr<IDataSender> BackgroundClient;
 		typedef std::map<int, BackgroundClient> BackgroundClients;
 
-		Tuner(const boost::filesystem::path & deviceFrontend);
-		~Tuner();
+		TunerI(const boost::filesystem::path & deviceFrontend);
+		~TunerI();
 
-		void TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&);
-		int GetStatus(const Ice::Current&);
-		std::string Device() const;
+		void TuneTo(const DVBSI::DeliveryPtr &) override;
+		int GetStatus() override;
+		std::string GetDevice() override;
 
-		void ScanAndSendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
-		void SendNetworkInformation(const RawDataClientPrx & client, const Ice::Current&);
-		void SendBouquetAssociations(const RawDataClientPrx & client, const Ice::Current&);
-		void SendServiceDescriptions(const RawDataClientPrx & client, const Ice::Current&);
-		void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current&);
-		void SendProgramAssociationTable(const RawDataClientPrx & client, const Ice::Current&);
-		void SendEventInformation(const RawDataClientPrx & client, const Ice::Current&);
+		void ScanAndSendNetworkInformation(const RawDataClientPrx & client) override;
+		void SendNetworkInformation(const RawDataClientPrx & client) override;
+		void SendBouquetAssociations(const RawDataClientPrx & client) override;
+		void SendServiceDescriptions(const RawDataClientPrx & client) override;
+		void SendProgramMap(Ice::Int pid, const RawDataClientPrx & client) override;
+		void SendProgramAssociationTable(const RawDataClientPrx & client) override;
+		void SendEventInformation(const RawDataClientPrx & client) override;
 
-		int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client, const Ice::Current &);
-		int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client, const Ice::Current &);
-		void StopSending(int handle, const Ice::Current &);
-
-		Ice::Long GetLastUsedTime(const Ice::Current&);
+		int StartSendingTS(const PacketIds & pids, const RawDataClientPrx & client) override;
+		int StartSendingSection(Ice::Int pid, const RawDataClientPrx & client) override;
+		void StopSending(int handle) override;
 
 	private:
 		int OpenDemux() const;
-		uint64_t SendPID(int pid, const RawDataClientPrx & client, const Ice::Current &) const;
+		uint64_t SendPID(int pid, const RawDataClientPrx & client) const;
 		void RequestPID(int pid, int fd) const;
 		uint64_t ReadDemuxAndSend(int fd, const RawDataClientPrx & client) const;
 		void startSenderThread();
@@ -75,7 +73,6 @@ class Tuner : public PrivateTuner {
 		std::thread * backgroundThread;
 		std::mutex lock;
 
-		mutable time_t lastUsedTime;
 		FrontendPtr frontend;
 		static IceTray::Logging::LoggerPtr logger;
 
diff --git a/p2pvr/devices/tunerSendSi.cpp b/p2pvr/devices/tunerSendSi.cpp
index 0215e47..3e09aaf 100644
--- a/p2pvr/devices/tunerSendSi.cpp
+++ b/p2pvr/devices/tunerSendSi.cpp
@@ -8,7 +8,7 @@ namespace DVB {
 IceTray::Logging::LoggerPtr SendSi::logger(LOGMANAGER()->getLogger<SendSi>());
 
 SendSi::SendSi(const RawDataClientPrx & c) :
-	Tuner::IDataSender(c->ice_collocationOptimized(false))
+	TunerI::IDataSender(c->ice_collocationOptimized(false))
 {
 }
 
diff --git a/p2pvr/devices/tunerSendSi.h b/p2pvr/devices/tunerSendSi.h
index 8b146ff..688fb2a 100644
--- a/p2pvr/devices/tunerSendSi.h
+++ b/p2pvr/devices/tunerSendSi.h
@@ -6,7 +6,7 @@
 
 namespace P2PVR {
 namespace DVB {
-class SendSi : public Tuner::IDataSender {
+class SendSi : public TunerI::IDataSender {
 	public:
 		SendSi(const P2PVR::RawDataClientPrx &);
 		~SendSi();
diff --git a/p2pvr/devices/tunerSendTs.cpp b/p2pvr/devices/tunerSendTs.cpp
index 8005311..fef418f 100644
--- a/p2pvr/devices/tunerSendTs.cpp
+++ b/p2pvr/devices/tunerSendTs.cpp
@@ -11,7 +11,7 @@ namespace DVB {
 IceTray::Logging::LoggerPtr SendTs::logger(LOGMANAGER()->getLogger<SendTs>());
 
 SendTs::SendTs(const RawDataClientPrx & c) :
-	Tuner::IDataSender(c->ice_collocationOptimized(false))
+	TunerI::IDataSender(c->ice_collocationOptimized(false))
 {
 	buffer.reserve(TARGET_BUFFER_SIZE);
 }
diff --git a/p2pvr/devices/tunerSendTs.h b/p2pvr/devices/tunerSendTs.h
index cd74198..bbec0a9 100644
--- a/p2pvr/devices/tunerSendTs.h
+++ b/p2pvr/devices/tunerSendTs.h
@@ -6,7 +6,7 @@
 
 namespace P2PVR {
 namespace DVB {
-class SendTs : public Tuner::IDataSender {
+class SendTs : public TunerI::IDataSender {
 	public:
 		SendTs(const P2PVR::RawDataClientPrx &);
 		~SendTs();
diff --git a/p2pvr/dvb/unittests/createBroadcast.cpp b/p2pvr/dvb/unittests/createBroadcast.cpp
index ee147f2..d381641 100644
--- a/p2pvr/dvb/unittests/createBroadcast.cpp
+++ b/p2pvr/dvb/unittests/createBroadcast.cpp
@@ -29,7 +29,7 @@ class Core {
 		{
 			adapter->activate();
 
-			devs = DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
+			devs = TunersPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
 			BOOST_REQUIRE(devs);
 			devs->ice_ping();
 		}
@@ -39,7 +39,7 @@ class Core {
 			ic->destroy();
 		}
 
-		DevicesPrx devs;
+		TunersPrx devs;
 		Ice::CommunicatorPtr ic;
 		Ice::ObjectAdapterPtr adapter;
 
@@ -47,7 +47,7 @@ class Core {
 
 class Sampler {
 	public:
-		Sampler(int sid, DevicesPrx d, Ice::ObjectAdapterPtr a) :
+		Sampler(int sid, TunersPrx d, Ice::ObjectAdapterPtr a) :
 				patp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pat)))),
 				pmtp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(pmt)))),
 				vidp(a, new DVBSI::BindDataHandler(boost::bind(&Sampler::Handle, this, _1, boost::ref(vid)))),
@@ -107,11 +107,6 @@ BOOST_AUTO_TEST_CASE( broadcast_sample )
 	BOOST_REQUIRE_EQUAL(transport->Frequency, 682000000);
 	BOOST_REQUIRE_EQUAL(transport->TransmissionMode, 1);
 
-	BOOST_TEST_CHECKPOINT("Acquire device");
-	P2PVR::TunerPrx tuner = devs->GetTunerSpecific(transport);
-	BOOST_REQUIRE(tuner);
-	tuner->ice_ping();
-
 	BOOST_TEST_CHECKPOINT("Create sampler");
 	P2PVR::Testing::Sampler sampler(4170, devs, adapter);
 
diff --git a/p2pvr/dvb/unittests/createSamples.cpp b/p2pvr/dvb/unittests/createSamples.cpp
index 6c477c9..3c07620 100644
--- a/p2pvr/dvb/unittests/createSamples.cpp
+++ b/p2pvr/dvb/unittests/createSamples.cpp
@@ -63,7 +63,7 @@ class SiSampleCollector : public Base {
 template <class Base, class Object>
 static
 void
-CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<void(TunerPrx, RawDataClientPrx)> & method)
+CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<void(TunersPrx, ::DVBSI::DeliveryPtr, RawDataClientPrx)> & method)
 {
 	auto icp = standardConfig<SiSampleCollector<Base, Object>>();
 	auto ic = boost::get<0>(icp);
@@ -71,7 +71,7 @@ CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<v
 	auto p = boost::get<2>(icp);
 	AdHoc::ScopeExit _([&ic]{ ic->destroy(); });
 
-	auto devs = DevicesPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
+	auto devs = TunersPrx::checkedCast(ic->stringToProxy("Devices:tcp -h defiant -p 10000"));
 	auto parser = RawDataClientPrx::checkedCast(adap->createProxy(ic->stringToIdentity("parser")));
 	BOOST_REQUIRE(devs);
 	devs->ice_ping();
@@ -85,15 +85,9 @@ CaptureAndSave(const boost::filesystem::path & fileName, const boost::function<v
 	BOOST_REQUIRE_EQUAL(transport->TransmissionMode, 1);
 
 	BOOST_TEST_CHECKPOINT("Acquire device");
-	TunerPrx tuner = devs->GetTunerAny(transport);
-	BOOST_REQUIRE(tuner);
-	tuner->ice_ping();
 
 	BOOST_TEST_CHECKPOINT("Get data");
-	method(tuner, parser);
-
-	BOOST_TEST_CHECKPOINT("Release device");
-	devs->ReleaseTuner(tuner);
+	method(devs, transport, parser);
 
 	BOOST_TEST_MESSAGE("Total packets: " << p->packets.size());
 	BOOST_REQUIRE(p->packets.size() > 0);
@@ -118,18 +112,18 @@ using namespace P2PVR::DVBSI;
 BOOST_AUTO_TEST_CASE( network_sample )
 {
 	CaptureAndSave<SiNetworkInformationParser, ::DVBSI::NetworkPtr>("network.dat",
-			[](TunerPrx t, RawDataClientPrx rdc) { t->SendNetworkInformation(rdc); });
+			[](TunersPrx t, ::DVBSI::DeliveryPtr del, RawDataClientPrx rdc) { t->SendNetworkInformation(del, rdc); });
 }
 
 BOOST_AUTO_TEST_CASE( services_sample )
 {
 	CaptureAndSave<SiServicesParser, ::DVBSI::TransportStreamPtr>("services.dat",
-			[](TunerPrx t, RawDataClientPrx rdc) { t->SendServiceDescriptions(rdc); });
+			[](TunersPrx t, ::DVBSI::DeliveryPtr del, RawDataClientPrx rdc) { t->SendServiceDescriptions(del, rdc); });
 }
 
 BOOST_AUTO_TEST_CASE( events_sample )
 {
 	CaptureAndSave<SiEpgParser, ::DVBSI::EventPtr>("events.dat",
-			[](TunerPrx t, RawDataClientPrx rdc) { t->SendEventInformation(rdc); });
+			[](TunersPrx t, ::DVBSI::DeliveryPtr del, RawDataClientPrx rdc) { t->SendEventInformation(del, rdc); });
 }
 
diff --git a/p2pvr/ice/dvb.ice b/p2pvr/ice/dvb.ice
index b306d1e..3c6ef87 100644
--- a/p2pvr/ice/dvb.ice
+++ b/p2pvr/ice/dvb.ice
@@ -14,6 +14,8 @@ module P2PVR {
 
 	exception IncorrectDeliveryType { };
 
+	exception NoSuitableDeviceAvailable { };
+
 	sequence<byte> Data;
 	sequence<short> PacketIds;
 
@@ -21,9 +23,9 @@ module P2PVR {
 		bool NewData(Data bytes) throws DataHandlingException;
 	};
 
-	interface Tuner {
+	local interface Tuner {
 		idempotent int GetStatus();
-		idempotent long GetLastUsedTime();
+		idempotent string GetDevice();
 
 		idempotent void SendNetworkInformation(RawDataClient * client) throws DeviceError, DataHandlingException;
 		idempotent void SendBouquetAssociations(RawDataClient * client) throws DeviceError, DataHandlingException;
@@ -35,35 +37,32 @@ module P2PVR {
 		int StartSendingTS(PacketIds pids, RawDataClient * client);
 		int StartSendingSection(int pid, RawDataClient * client);
 		idempotent void StopSending(int handle);
-	};
-
-	interface PrivateTuner extends Tuner {
 		idempotent void TuneTo(DVBSI::Delivery d) throws DeviceError;
 		idempotent void ScanAndSendNetworkInformation(RawDataClient * client) throws DeviceError, DataHandlingException;
 	};
 
-	exception NoSuitableDeviceAvailable { };
-
-	interface Devices {
-		// Get a tuner that is tuned to <del>, acquire and tune to <del> if required.
-		Tuner * GetTunerSpecific(DVBSI::Delivery del);
-		// Get any tuner that is tuned, acquire and tune to <del> if required.
-		Tuner * GetTunerAny(DVBSI::Delivery del);
-		// Get a private tuner, not shared or sharable
-		PrivateTuner * GetPrivateTuner(short type);
-		// Release a tuner when no longer required.
-		idempotent void ReleaseTuner(Tuner * t);
-		// Count available tuners
-		idempotent int TunerCount();
-	};
-
-	interface LocalDevices extends Devices {
-		// Add/remove according to device nodes in /dev/dvb/...
-		idempotent void Scan();
+	interface Tuners {
+		// Add/remove according to device nodes in "path"
+		idempotent void Scan(string path);
 		// Add a device
 		idempotent void Add(string frontend);
 		// Remove a device
 		idempotent void Remove(string frontend);
+		// How many registered devices?
+		idempotent int TunerCount();
+
+		idempotent void ScanAndSendNetworkInformation(RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+
+		idempotent void SendNetworkInformation(DVBSI::Delivery del, RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+		idempotent void SendBouquetAssociations(DVBSI::Delivery del, RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+		idempotent void SendServiceDescriptions(DVBSI::Delivery del, RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+		idempotent void SendProgramAssociationTable(DVBSI::Delivery del, RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+		idempotent void SendProgramMap(DVBSI::Delivery del, int pid, RawDataClient * client) throws DeviceError, DataHandlingException, NoSuitableDeviceAvailable;
+		idempotent void SendEventInformation(DVBSI::Delivery del, RawDataClient * client) throws DeviceError, NoSuitableDeviceAvailable;
+
+		int StartSendingTS(DVBSI::Delivery del, PacketIds pids, RawDataClient * client) throws NoSuitableDeviceAvailable;
+		int StartSendingSection(DVBSI::Delivery del, int pid, RawDataClient * client) throws NoSuitableDeviceAvailable;
+		idempotent void StopSending(int handle);
 	};
 };
 
diff --git a/p2pvr/lib/serviceStreamer.cpp b/p2pvr/lib/serviceStreamer.cpp
index 7e99008..2b88643 100644
--- a/p2pvr/lib/serviceStreamer.cpp
+++ b/p2pvr/lib/serviceStreamer.cpp
@@ -1,7 +1,7 @@
 #include "serviceStreamer.h"
 
 namespace P2PVR {
-ServiceStreamer::ServiceStreamer(int sid, RawDataClientPrx t, const DevicesPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a) :
+ServiceStreamer::ServiceStreamer(int sid, RawDataClientPrx t, const TunersPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a) :
 	ServiceStreamerCore(sid, t, t, t, d, a),
 	si(s)
 {
diff --git a/p2pvr/lib/serviceStreamer.h b/p2pvr/lib/serviceStreamer.h
index 17c7850..165d5a0 100644
--- a/p2pvr/lib/serviceStreamer.h
+++ b/p2pvr/lib/serviceStreamer.h
@@ -8,7 +8,7 @@
 namespace P2PVR {
 class DLL_PUBLIC ServiceStreamer : public ServiceStreamerCore {
 	public:
-		ServiceStreamer(int sid, RawDataClientPrx, const DevicesPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a);
+		ServiceStreamer(int sid, RawDataClientPrx, const TunersPrx & d, const SIPrx & s, const Ice::ObjectAdapterPtr & a);
 		~ServiceStreamer();
 
 		void Start();
diff --git a/p2pvr/lib/serviceStreamerCore.cpp b/p2pvr/lib/serviceStreamerCore.cpp
index 6299a89..1c37027 100644
--- a/p2pvr/lib/serviceStreamerCore.cpp
+++ b/p2pvr/lib/serviceStreamerCore.cpp
@@ -6,7 +6,7 @@ namespace P2PVR {
 IceTray::Logging::LoggerPtr ServiceStreamerCore::log(LOGMANAGER()->getLogger<ServiceStreamerCore>());
 
 ServiceStreamerCore::ServiceStreamerCore(int sid, RawDataClientPrx pat, RawDataClientPrx pmt, RawDataClientPrx ser,
-		DevicesPrx d, Ice::ObjectAdapterPtr a) :
+		TunersPrx d, Ice::ObjectAdapterPtr a) :
 	adapter(a),
 	devs(d),
 	patTarget(pat),
@@ -17,7 +17,6 @@ ServiceStreamerCore::ServiceStreamerCore(int sid, RawDataClientPrx pat, RawDataC
 	serviceId(sid),
 	patHandle(0), pmtStream(0), pmtHandle(0), serviceHandle(0)
 {
-
 }
 
 ServiceStreamerCore::~ServiceStreamerCore()
@@ -32,7 +31,7 @@ ServiceStreamerCore::HandlePAT(const DVBSI::ProgramAssociationMapPtr & pam)
 		pmtStream = p->second;
 		log->messagef(LOG::DEBUG, "%s: Got ProgramAssociationMap, pmtStream now = %d", __PRETTY_FUNCTION__, pmtStream);
 		stopHandle(pmtHandle);
-		pmtHandle = tuner->StartSendingSection(pmtStream, pmtParser);
+		pmtHandle = devs->StartSendingSection(transport, pmtStream, pmtParser);
 	}
 	patTarget->NewData(patParser.Get()->CurrentRawData());
 	return false;
@@ -51,17 +50,17 @@ ServiceStreamerCore::HandlePMT(const ::DVBSI::ProgramMapPtr & pmp)
 		streams = strms;
 		log->messagebf(LOG::DEBUG, "%s: Got ProgramMap, switching to %d streams", __PRETTY_FUNCTION__, streams.size());
 		stopHandle(serviceHandle);
-		serviceHandle = tuner->StartSendingTS(PacketIds(streams.begin(), streams.end()), serTarget);
+		serviceHandle = devs->StartSendingTS(transport, PacketIds(streams.begin(), streams.end()), serTarget);
 	}
 	pmtTarget->NewData(pmtParser.Get()->CurrentRawData());
 	return false;
 }
 
 void
-ServiceStreamerCore::Start(::DVBSI::DeliveryPtr transport)
+ServiceStreamerCore::Start(::DVBSI::DeliveryPtr t)
 {
-	tuner = devs->GetTunerSpecific(transport);
-	patHandle = tuner->StartSendingSection(0, patParser);
+	transport = t;
+	patHandle = devs->StartSendingSection(transport, 0, patParser);
 }
 
 void
@@ -70,15 +69,14 @@ ServiceStreamerCore::Stop()
 	stopHandle(serviceHandle);
 	stopHandle(patHandle);
 	stopHandle(pmtHandle);
-	devs->ReleaseTuner(tuner);
-	tuner = NULL;
+	transport = NULL;
 }
 
 void
 ServiceStreamerCore::stopHandle(int & handle)
 {
 	if (handle) {
-		tuner->StopSending(handle);
+		devs->StopSending(handle);
 		handle = 0;
 	}
 }
diff --git a/p2pvr/lib/serviceStreamerCore.h b/p2pvr/lib/serviceStreamerCore.h
index f8ec1f6..c134fec 100644
--- a/p2pvr/lib/serviceStreamerCore.h
+++ b/p2pvr/lib/serviceStreamerCore.h
@@ -15,7 +15,7 @@ namespace P2PVR {
 class DLL_PUBLIC ServiceStreamerCore {
 	public:
 		ServiceStreamerCore(int sid, RawDataClientPrx, RawDataClientPrx, RawDataClientPrx,
-				DevicesPrx, Ice::ObjectAdapterPtr);
+				TunersPrx, Ice::ObjectAdapterPtr);
 		virtual ~ServiceStreamerCore();
 
 		void Start(::DVBSI::DeliveryPtr);
@@ -27,13 +27,13 @@ class DLL_PUBLIC ServiceStreamerCore {
 		void stopHandle(int & handle);
 
 		const Ice::ObjectAdapterPtr & adapter;
-		DevicesPrx devs;
+		TunersPrx devs;
 		RawDataClientPrx patTarget;
 		RawDataClientPrx pmtTarget;
 		RawDataClientPrx serTarget;
 		TemporaryIceAdapterObject<DVBSI::SiTableParserBase> patParser;
 		TemporaryIceAdapterObject<DVBSI::SiTableParserBase> pmtParser;
-		TunerPrx tuner;
+		::DVBSI::DeliveryPtr transport;
 
 		int serviceId;
 		int patHandle;