Starting to redesign server communication.

9 files changed, 153 insertions, 144 deletions

diff --git a/PlexServer.cpp b/PlexServer.cpp
index 687c8d1..00a41eb 100644
--- a/PlexServer.cpp
+++ b/PlexServer.cpp
@@ -1,5 +1,7 @@
 #include <vdr/tools.h>
 #include "PlexServer.h"
+#include "Config.h"
+#include "plex.h"
 
 namespace plexclient
 {
@@ -103,6 +105,40 @@ Poco::Net::HTTPClientSession* PlexServer::GetClientSession()
 	return m_httpSession;
 }
 
+std::istream& PlexServer::MakeRequest(Poco::Net::HTTPResponse& response, std::string path, std::map<std::string, std::string> queryParameters)
+{
+	Poco::URI uri(path);
+	// Create a request with an optional query
+	if(queryParameters.size()) {
+		for (auto const& pair : queryParameters) {
+			// addQueryParameter does the encode already
+			uri.addQueryParameter(pair.first, pair.second);
+		}
+	}
+	
+	Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, uri.getPathAndQuery(), Poco::Net::HTTPMessage::HTTP_1_1);
+
+	request.add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.52 Safari/537.17");
+	request.add("X-Plex-Client-Identifier", Config::GetInstance().GetUUID());
+	request.add("X-Plex-Device", "PC");
+	request.add("X-Plex-Device-Name", Config::GetInstance().GetHostname());
+	request.add("X-Plex-Language", Config::GetInstance().GetLanguage());
+	request.add("X-Plex-Model", "Linux");
+	request.add("X-Plex-Platform", "VDR");
+	request.add("X-Plex-Product", "plex for vdr");
+	request.add("X-Plex-Provides", "player");
+	request.add("X-Plex-Version", VERSION);
+
+	if(Config::GetInstance().UsePlexAccount && !GetAuthToken().empty()) {
+		// Add PlexToken to Header
+		request.add("X-Plex-Token", GetAuthToken());
+	}
+	
+	GetClientSession()->sendRequest(request);
+	return GetClientSession()->receiveResponse(response);
+	
+}
+
 std::string PlexServer::GetUri()
 {
 	return  m_uri;
diff --git a/PlexServer.h b/PlexServer.h
index e530aa9..61031a0 100644
--- a/PlexServer.h
+++ b/PlexServer.h
@@ -7,11 +7,13 @@
 #include <iostream>
 #include <vector>
 #include <memory>
+#include <map>
 
 #include <Poco/String.h>
 #include <Poco/Net/HTTPClientSession.h>
 #include <Poco/Net/HTTPSClientSession.h>
 #include <Poco/Net/HTTPRequest.h>
+#include <Poco/Net/HTTPResponse.h>
 #include <Poco/Net/MessageHeader.h>
 #include <Poco/URI.h>
 
@@ -60,6 +62,11 @@ class PlexServer
 	const bool& IsLocal() const {
 		return m_bLocal;
 	}
+	void SetAuthToken(std::string token) {
+		m_authToken = token;
+	}
+	
+	std::istream& MakeRequest(Poco::Net::HTTPResponse& response, std::string path, std::map<std::string, std::string> queryParameters = std::map<std::string, std::string>());
 	
 	std::string GetHost();
 	int GetPort();
diff --git a/Plexservice.cpp b/Plexservice.cpp
index 3bb1c2a..1177c70 100644
--- a/Plexservice.cpp
+++ b/Plexservice.cpp
@@ -34,12 +34,9 @@ std::string Plexservice::GetMyPlexToken()
 		b64.close();
 		std::string tempToken = ss.str();
 
-		Poco::Net::Context::Ptr context = new Poco::Net::Context(
-		    Poco::Net::Context::CLIENT_USE, "", "", "", Poco::Net::Context::VERIFY_NONE, // VERIFY_NONE...?!
-		    9, false, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
 
 		try {
-			Poco::Net::HTTPSClientSession plexSession("plex.tv", 443, context);
+			Poco::Net::HTTPSClientSession plexSession("plex.tv", 443);
 			Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, "/users/sign_in.xml", Poco::Net::HTTPMessage::HTTP_1_1);
 
 			PlexHelper::AddHttpHeader(request);
@@ -98,7 +95,29 @@ void Plexservice::UpdateResources()
 	}
 	isyslog("[plex] Updating remote resources...");
 
-	std::shared_ptr<MediaContainer> pContainer = GetMediaContainer("https://plex.tv/api/resources?includeHttps=1");
+
+	std::shared_ptr<MediaContainer> pContainer = nullptr;
+	try {
+		Poco::URI fileuri("https://plex.tv/api/resources?includeHttps=1");
+
+		Poco::Net::HTTPSClientSession session(fileuri.getHost(), 443);		
+
+		Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, fileuri.getPathAndQuery(), Poco::Net::HTTPMessage::HTTP_1_1);
+		PlexHelper::AddHttpHeader(request);
+		request.add("X-Plex-Token", GetMyPlexToken() );
+
+		session.sendRequest(request);
+		Poco::Net::HTTPResponse response;
+		std::istream &rs = session.receiveResponse(response);
+		
+		//Poco::StreamCopier::copyStream(rs, std::cout);
+
+		pContainer = std::shared_ptr<MediaContainer>(new MediaContainer(&rs));
+
+	} catch (Poco::Net::NetException &exc) {
+		std::cout << exc.displayText() << std::endl;
+		return;
+	}
 
 	for(std::vector<Device>::iterator d_it = pContainer->m_vDevices.begin(); d_it != pContainer->m_vDevices.end(); ++d_it) {
 
@@ -140,16 +159,12 @@ std::shared_ptr<MediaContainer> Plexservice::GetSection(std::string section, boo
 		}
 
 		dsyslog("[plex] URI: %s%s", pServer->GetUri().c_str(), uri.c_str());
-		//Poco::Net::HTTPClientSession session(pServer->GetHost(), pServer->GetPort());
-		//session.sendRequest(*pRequest);
-		pServer->GetClientSession()->sendRequest(*pRequest);
+		
 		Poco::Net::HTTPResponse response;
-		std::istream &rs = pServer->GetClientSession()->receiveResponse(response);
-
+		std::istream &rs = pServer->MakeRequest(response, uri);;
 
 		std::shared_ptr<MediaContainer> pAllsections(new MediaContainer(&rs, pServer));
 
-		//session.abort();
 		return pAllsections;
 
 	} catch (Poco::Net::NetException &exc) {
@@ -200,122 +215,75 @@ std::unique_ptr<Poco::Net::HTTPRequest> Plexservice::CreateRequest(std::string p
 
 std::shared_ptr<MediaContainer> Plexservice::GetMediaContainer(std::string fullUrl)
 {
-	Poco::Net::HTTPClientSession* pSession = NULL;
 	PlexServer* pServer = NULL;
-	bool ownSession = false;
 	try {
 		Poco::URI fileuri(fullUrl);
 		dsyslog("[plex] GetMediaContainer: %s", fullUrl.c_str());
 
-		if(fileuri.getHost().find("plex.tv") != std::string::npos) {
-			if(fileuri.getScheme().find("https") != std::string::npos) {
-				pSession = new Poco::Net::HTTPSClientSession(fileuri.getHost(), fileuri.getPort());
-			} else {
-				pSession = new Poco::Net::HTTPClientSession(fileuri.getHost(), fileuri.getPort());
-			}
-			ownSession = true;
-		}
-		else {
-			pServer = plexgdm::GetInstance().GetServer(fileuri.getHost(), fileuri.getPort());
-			pSession = pServer->GetClientSession();
-		}
+		pServer = plexgdm::GetInstance().GetServer(fileuri.getHost(), fileuri.getPort());
 		
-		
-		
-		// > HTTPS
-
-		Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, fileuri.getPathAndQuery(), Poco::Net::HTTPMessage::HTTP_1_1);
-		PlexHelper::AddHttpHeader(request);
-
-		if(Config::GetInstance().UsePlexAccount) {
-			// Add PlexToken to Header
-			std::string token = GetMyPlexToken();
-			if(pServer && !pServer->GetAuthToken().empty()) {
-				request.add("X-Plex-Token", pServer->GetAuthToken());
-				dsyslog("[plex] Using server access token");
-			} else if(!token.empty()) {
-				request.add("X-Plex-Token", token);
-				dsyslog("[plex] Using global access token");
-			}
-		}
-
-
-		pSession->sendRequest(request);
 		Poco::Net::HTTPResponse response;
-		std::istream &rs = pSession->receiveResponse(response);
+		std::istream &rs = pServer->MakeRequest(response, fileuri.getPathAndQuery());
 
 		//Poco::StreamCopier::copyStream(rs, std::cout);
 
 		std::shared_ptr<MediaContainer> pAllsections = std::shared_ptr<MediaContainer>(new MediaContainer(&rs, pServer));
-		if (ownSession) delete pSession;
 		return pAllsections;
 	} catch (Poco::Net::NetException &exc) {
 		std::cout << exc.displayText() << std::endl;
 		return 0;
 	}
 }
-
+/*
 std::string Plexservice::encode(std::string message)
 {
 	std::string temp;
 	Poco::URI::encode(message, " !\"#$%&'()*+,/:;=?@[]", temp);
 	return temp;
 }
-
-std::string Plexservice::GetUniversalTranscodeUrl(Video* video, int offset, PlexServer* server)
+*/
+std::string Plexservice::GetUniversalTranscodeUrl(Video* video, int offset, PlexServer* server, bool http)
 {
 	PlexServer* pSrv = server ? server : video->m_pServer;
-	std::stringstream params;
-	params << "/video/:/transcode/universal/start.m3u8?";
+	Poco::URI transcodeUri(pSrv->GetUri());
+	transcodeUri.setPath("/video/:/transcode/universal/start.m3u8");
+	
 	// Force set localhost and http
 	Poco::URI pathUri(pSrv->GetUri()+video->m_sKey);
 	pathUri.setHost("127.0.0.1");
 	pathUri.setScheme("http");
 	
-	params << "path=" << encode(pathUri.toString());
-	params << "&mediaIndex=0";
-	params << "&partIndex=0";
-	params << "&protocol=hls";
-	params << "&offset=" << offset;
-	params << "&fastSeek=0";
-	params << "&directPlay=0";
-	params << "&directStream=1";
-	params << "&subtitles=burn";
-	//params << "&subtitleSize=90";
-	//params << "&skipSubtitles=1";
-	//params << "&audioBoost=100";
-	
-	if(Config::GetInstance().UsePlexAccount) {
-		if(!pSrv->GetAuthToken().empty()) {
-			params << "&X-Plex-Token=" << pSrv->GetAuthToken();
-		}
-	}
+	transcodeUri.addQueryParameter("path", pathUri.toString());
+	transcodeUri.addQueryParameter("mediaIndex", "0");
+	transcodeUri.addQueryParameter("partIndex", "0");
+	transcodeUri.addQueryParameter("protocol", "hls");
+	transcodeUri.addQueryParameter("offset", std::to_string(offset) );
+	transcodeUri.addQueryParameter("fastSeek", "1");
+	transcodeUri.addQueryParameter("directPlay", "0");
+	transcodeUri.addQueryParameter("directStream", "1");
+	transcodeUri.addQueryParameter("subtitles", "burn");
+	transcodeUri.addQueryParameter("audioBoost", "100");
 	
 	if(pSrv->IsLocal()) {
-		params << "&videoResolution=1920x1080";
-		params << "&maxVideoBitrate=20000";
-		params << "&videoQuality=100";
+		transcodeUri.addQueryParameter("videoResolution", "1920x1080");
+		transcodeUri.addQueryParameter("maxVideoBitrate", "20000");
+		transcodeUri.addQueryParameter("videoQuality", "100");
 	} else {
-		params << "&videoResolution=1280x720";
-		params << "&maxVideoBitrate=8000";
-		params << "&videoQuality=100";
+		transcodeUri.addQueryParameter("videoResolution", "1280x720");
+		transcodeUri.addQueryParameter("maxVideoBitrate", "8000");
+		transcodeUri.addQueryParameter("videoQuality", "100");
 	}
-	
-	params << "&session=" << encode(Config::GetInstance().GetUUID()); // TODO: generate Random SessionID
-
-	params << "&includeCodecs=1";
-	params << "&copyts=1";
+	transcodeUri.addQueryParameter("session", Config::GetInstance().GetUUID()); // TODO: generate Random SessionID
+	transcodeUri.addQueryParameter("includeCodecs", "1");
+	transcodeUri.addQueryParameter("copyts", "1");
 
 	if(Config::GetInstance().UseAc3) {
-		params << "&X-Plex-Client-Profile-Extra=";
-		if(Config::GetInstance().UseAc3)
-			params << encode("add-transcode-target-audio-codec(type=videoProfile&context=streaming&protocol=hls&audioCodec=ac3)");
-
+		transcodeUri.addQueryParameter("X-Plex-Client-Profile-Extra", "add-transcode-target-audio-codec(type=videoProfile&context=streaming&protocol=hls&audioCodec=ac3");
 		//params << encode("+add-limitation(scope=videoCodec&scopeName=h264&type=lowerBound&name=video.height&value=1080)");
 		//params << encode("+add-limitation(scope=videoCodec&scopeName=h264&type=lowerBound&name=video.frameRate&value=25)");
 		//params << encode("+add-limitation(scope=videoCodec&scopeName=h264&type=upperBound&name=video.frameRate&value=25)");
 	}
-	return pSrv->GetUri() + params.str();
+	return transcodeUri.toString();
 }
 
 }
diff --git a/Plexservice.h b/Plexservice.h
index 7897281..097106f 100644
--- a/Plexservice.h
+++ b/Plexservice.h
@@ -49,10 +49,10 @@ public:
 	PlexServer* GetServer();
 	void Authenticate();
 	
-	static std::string GetUniversalTranscodeUrl(Video* video, int offset = 0, PlexServer* server = 0);
+	static std::string GetUniversalTranscodeUrl(Video* video, int offset = 0, PlexServer* server = 0, bool http = false);
 	static std::string GetMyPlexToken();
 	static std::shared_ptr<MediaContainer> GetMediaContainer(std::string fullUrl);
-	static std::string encode(std::string message);
+	//static std::string encode(std::string message);
 	static void UpdateResources();
 
 	std::string StartUri;
diff --git a/SubscriptionManager.cpp b/SubscriptionManager.cpp
index 67ab723..061f823 100644
--- a/SubscriptionManager.cpp
+++ b/SubscriptionManager.cpp
@@ -59,14 +59,15 @@ void SubscriptionManager::ReportProgress()
 		std::string state = "playing";
 		if (m_pStatus->PlayerStopped)	state = "stopped";
 		else if(!play) 					state = "paused";
-		
-		Poco::Net::HTTPClientSession session(m_pStatus->pVideo->m_pServer->GetHost(), m_pStatus->pVideo->m_pServer->GetPort());
-		std::string uri = "/:/progress?key=" + std::string(itoa(m_pStatus->pVideo->m_iRatingKey)) + "&identifier=com.plexapp.plugins.library&time=" + std::string(itoa(current)) + "&state=" + state;
-		Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, uri);
-		session.sendRequest(req);
 
+		std::map<std::string, std::string> queryMap;
+		queryMap["key"] = std::to_string(m_pStatus->pVideo->m_iRatingKey);
+		queryMap["identifier"] = "com.plexapp.plugins.library";
+		queryMap["time"] = std::to_string(current);
+		queryMap["state"] = state;
+		
 		Poco::Net::HTTPResponse resp;
-		session.receiveResponse(resp);
+		m_pStatus->pVideo->m_pServer->MakeRequest(resp, "/:/progress", queryMap);
 
 	} catch (Poco::Exception&) {}
 }
@@ -88,40 +89,33 @@ void SubscriptionManager::NotifyServer()
 			return;
 		}
 		
-		std::string server;
-		int port;
+		PlexServer* pServer;
 		if(pVid) {
-			server = pVid->m_pServer->GetHost();
-			port = pVid->m_pServer->GetPort();
+			pServer = pVid->m_pServer;
 		} else if ( plexgdm::GetInstance().GetPlexservers().size() > 0) {
-			server = plexgdm::GetInstance().GetPlexservers().at(0).GetHost();
-			port = plexgdm::GetInstance().GetPlexservers().at(0).GetPort();
+			pServer = &plexgdm::GetInstance().GetPlexservers().at(0);
 		} else {
 			// no plexservers in network
 			return;
 		}
+		
+		std::map<std::string, std::string> queryMap;
 
-		std::stringstream uri;
-		uri << "/:/timeline";
-		uri << "?containerKey=" << Plexservice::encode(pVid ? pVid->m_sKey : "/library/metadata/900000");
-		uri << "&key=" << Plexservice::encode(pVid ? pVid->m_sKey : "/library/metadata/900000");
-		uri << "&ratingKey=" << (pVid ? pVid->m_iRatingKey : 900000);
-		uri << "&state=";
-		if (m_pStatus->PlayerStopped)	uri << "stopped";
-		else if(!play) 					uri << "paused";
-		else 							uri << "playing";
-		uri << "&time=" << current;
-		uri << "&duration=" << total;
-
-		Poco::Net::HTTPRequest Request(Poco::Net::HTTPRequest::HTTP_GET, uri.str(), Poco::Net::HTTPMessage::HTTP_1_1);
+		queryMap["containerKey"] = pVid ? pVid->m_sKey : "/library/metadata/900000";
+		queryMap["key"] = pVid ? pVid->m_sKey : "/library/metadata/900000";
+		queryMap["ratingKey"] = pVid ? std::to_string(pVid->m_iRatingKey) : "900000";
 
-		PlexHelper::AddHttpHeader(Request);
-				
-		Poco::Net::HTTPClientSession session(server, port);
+		if (m_pStatus->PlayerStopped)	queryMap["state"] = "stopped";
+		else if(!play) 					queryMap["state"] = "paused";
+		else 							queryMap["state"] = "playing";
+		
+		queryMap["time"] = std::to_string(current);
+		queryMap["duration"] = std::to_string(total);
 
-		session.sendRequest(Request);
+		
 		Poco::Net::HTTPResponse response;
-		session.receiveResponse(response);
+		pServer->MakeRequest(response, "/:/timeline", queryMap);
+		
 
 		if(m_pStatus->PlayerStopped) {
 			m_bStoppedSent = true;
diff --git a/hlsPlayer.cpp b/hlsPlayer.cpp
index 1baa75a..f23db0c 100644
--- a/hlsPlayer.cpp
+++ b/hlsPlayer.cpp
@@ -20,8 +20,9 @@ static cMutex hlsMutex;
 
 //--- cHlsSegmentLoader
 
-cHlsSegmentLoader::cHlsSegmentLoader(std::string startm3u8)
+cHlsSegmentLoader::cHlsSegmentLoader(std::string startm3u8, plexclient::Video* pVideo)
 {
+	m_pVideo = pVideo;
 	m_newList = false;
 	m_bufferFilled = false;
 	m_lastLoadedSegment = 0;
@@ -449,7 +450,6 @@ int cHlsSegmentLoader::GetStreamLenght()
 cHlsPlayer::cHlsPlayer(std::string startm3u8, plexclient::Video Video, int offset)
 {
 	dsyslog("[plex]: '%s'", __FUNCTION__);
-	m_pSegmentLoader = new cHlsSegmentLoader(startm3u8);
 	m_Video = Video;
 	m_timeOffset = offset;
 	m_jumpOffset = 0;
@@ -458,8 +458,9 @@ cHlsPlayer::cHlsPlayer(std::string startm3u8, plexclient::Video Video, int offse
 	m_isBuffering = false;
 	AudioIndexOffset = 1000; // Just a magic number
 	m_tTimer.Set(1);
+	m_pSegmentLoader = new cHlsSegmentLoader(startm3u8, &m_Video);
+	
 	m_pDebugFile = NULL;
-
 	//m_pDebugFile = new std::ofstream();
 	//m_pDebugFile->open("debug.ts", std::ios::out);
 }
@@ -677,15 +678,10 @@ void cHlsPlayer::SetAudioTrack(eTrackType Type __attribute__((unused)), const tT
 	}
 	// Then do the request
 	if(streamId > 0) {
-		Poco::Net::HTTPClientSession session(m_Video.m_pServer->GetHost(), m_Video.m_pServer->GetPort());
-
 		std::string uri = "/library/parts/" + std::string(itoa(m_Video.m_Media.m_iPartId)) + "?audioStreamID=" + std::string(itoa(streamId));
-		Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_PUT, uri);
-		session.sendRequest(req);
 
 		Poco::Net::HTTPResponse resp;
-		session.receiveResponse(resp);
-
+		m_Video.m_pServer->MakeRequest(resp, uri);
 		if(resp.getStatus() == 200) {
 			DeviceSetCurrentAudioTrack(eTrackType(ttDolby + 0)); // hacky
 			DeviceSetAvailableTrack(ttDolby, 0, 0, TrackId->language);
@@ -729,13 +725,10 @@ void cHlsPlayer::ReportProgress(bool stopped)
 	}
 
 	try {
-		Poco::Net::HTTPClientSession session(m_Video.m_pServer->GetHost(), m_Video.m_pServer->GetPort());
 		std::string uri = "/:/progress?key=" + std::string(itoa(m_Video.m_iRatingKey)) + "&identifier=com.plexapp.plugins.library&time=" + std::string(itoa(GetPlayedSeconds()*1000)) + "&state=" + state;
-		Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, uri);
-		session.sendRequest(req);
 
 		Poco::Net::HTTPResponse resp;
-		session.receiveResponse(resp);
+		m_Video.m_pServer->MakeRequest(resp, uri);
 
 		if(resp.getStatus() == 200) {
 			dsyslog("[plex] %s", __FUNCTION__);
@@ -746,14 +739,11 @@ void cHlsPlayer::ReportProgress(bool stopped)
 
 void cHlsPlayer::SetWatched(void)
 {
-	Poco::Net::HTTPClientSession session(m_Video.m_pServer->GetHost(), m_Video.m_pServer->GetPort());
 	std::string uri = "/:/scrobble?key=" + std::string(itoa(m_Video.m_iRatingKey)) + "&identifier=com.plexapp.plugins.library";
-	Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, uri);
-	session.sendRequest(req);
 
 	Poco::Net::HTTPResponse resp;
-	session.receiveResponse(resp);
-
+	m_Video.m_pServer->MakeRequest(resp, uri);
+	
 	if(resp.getStatus() == 200) {
 		dsyslog("[plex] %s", __FUNCTION__);
 	}
diff --git a/hlsPlayer.h b/hlsPlayer.h
index 1e88deb..774aa07 100644
--- a/hlsPlayer.h
+++ b/hlsPlayer.h
@@ -33,6 +33,7 @@ private:
 	uchar* m_pBuffer;
 
 	Poco::Net::HTTPClientSession* m_pClientSession;
+	plexclient::Video* m_pVideo
 	Poco::URI m_startUri;
 	std::string m_sessionUriPart;
 	std::string m_segmentUriPart;
@@ -59,7 +60,7 @@ protected:
 	bool DoLoad(void);
 
 public:
-	cHlsSegmentLoader(std::string startm3u8);
+	cHlsSegmentLoader(std::string startm3u8, plexclient::Video* pVideo);
 	~cHlsSegmentLoader();
 
 	cRingBufferLinear*  m_pRingbuffer;
diff --git a/plex.cpp b/plex.cpp
index 8c3f212..aa6e022 100644
--- a/plex.cpp
+++ b/plex.cpp
@@ -211,8 +211,14 @@ void cMyPlugin::PlayFile(plexclient::Video Vid)
 
 		Mpv_PlayFile req;
 		Mpv_SetTitle reqTitle;
-		char* file = (char*)(Vid.m_pServer->GetUri() + Vid.m_Media.m_sPartKey).c_str();
-
+		char* file;
+		if(Config::GetInstance().UsePlexAccount && Vid.m_pServer->IsLocal() == false) {
+			file = (char*)plexclient::Plexservice::GetUniversalTranscodeUrl(&Vid, Vid.m_iMyPlayOffset, NULL, true).c_str();
+		}
+		else {
+			 file = (char*)(Vid.m_pServer->GetUri() + Vid.m_Media.m_sPartKey).c_str();
+		}
+		
 		req.Filename = file;
 		mpvPlugin->Service(MPV_PLAY_FILE, &req);
 
diff --git a/plexgdm.cpp b/plexgdm.cpp
index dae0df3..e76279d 100644
--- a/plexgdm.cpp
+++ b/plexgdm.cpp
@@ -59,15 +59,18 @@ std::string plexgdm::getClientDetails()
 
 void plexgdm::Action()
 {
-	
-	// Get remote Resources
-	Plexservice::UpdateResources();
-	
 	if(Config::GetInstance().UseConfiguredServer) {
 		// Adds a Server to vector
 		GetServer(Config::GetInstance().s_serverHost, Config::GetInstance().ServerPort);
+
+		if(Config::GetInstance().UsePlexAccount) {
+			GetServer(Config::GetInstance().s_serverHost, Config::GetInstance().ServerPort)->SetAuthToken(Plexservice::GetMyPlexToken());
+		}
 	}
 	
+	// Get remote Resources
+	Plexservice::UpdateResources();
+	
 	char buffer[1024];
 	m_registrationIsRunning = true;
 	m_discoveryIsRunning = true;
@@ -177,6 +180,10 @@ void plexgdm::discover()
 			}
 			if(flag) {
 				m_vServers.push_back(PlexServer(data, host));
+				// Set token for local servers
+				if(Config::GetInstance().UsePlexAccount) {
+					m_vServers[m_vServers.size()-1].SetAuthToken(Plexservice::GetMyPlexToken());
+				}
 				isyslog("[plex] New Server Discovered: %s", host.c_str());
 			}
 		}