/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnDeviceRemoved
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnDeviceRemoved(PLT_DeviceDataReference& device)
{
PLT_DeviceDataReference data;
{
NPT_AutoLock lock(m_MediaServers);
// only release if we have kept it around
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_FAILED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) not found in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE("Device Removed:");
device->ToLog(NPT_LOG_LEVEL_FINE);
m_MediaServers.Remove(device);
}
if (m_Listener) {
m_Listener->OnMSAddedRemoved(device, 0);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnDeviceRemoved
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnDeviceRemoved(PLT_DeviceDataReference& device)
{
if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaServer"))
return NPT_FAILURE;
{
NPT_AutoLock lock(m_MediaServers);
// only release if we have kept it around
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// Have we seen that device?
if (NPT_FAILED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) not found in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE_1("Device Removed: %s", (const char*)*device);
m_MediaServers.Remove(device);
}
if (m_Delegate) {
m_Delegate->OnMSRemoved(device);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnDeviceAdded(PLT_DeviceDataReference& device)
{
// verify the device implements the function we need
PLT_Service* serviceCDS;
PLT_Service* serviceCMR;
NPT_String type;
if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaServer"))
return NPT_FAILURE;
type = "urn:schemas-upnp-org:service:ContentDirectory:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceCDS))) {
NPT_LOG_WARNING_2("Service %s not found in device \"%s\"",
type.GetChars(),
device->GetFriendlyName().GetChars());
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceCDS->ForceVersion(1);
}
type = "urn:schemas-upnp-org:service:ConnectionManager:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
NPT_LOG_WARNING_2("Service %s not found in device \"%s\"",
type.GetChars(),
device->GetFriendlyName().GetChars());
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceCMR->ForceVersion(1);
}
{
NPT_AutoLock lock(m_MediaServers);
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) is already in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE_1("Device Found: %s", (const char*)*device);
m_MediaServers.Add(device);
}
if (m_Delegate && m_Delegate->OnMSAdded(device)) {
m_CtrlPoint->Subscribe(serviceCDS);
m_CtrlPoint->Subscribe(serviceCMR);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::FindServer
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::FindServer(const char* uuid, PLT_DeviceDataReference& device)
{
NPT_AutoLock lock(m_MediaServers);
if (NPT_FAILED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), device))) {
NPT_LOG_FINE_1("Device (%s) not found in our list of servers", (const char*)uuid);
return NPT_FAILURE;
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnDeviceAdded(PLT_DeviceDataReference& device)
{
// verify the device implements the function we need
PLT_Service* serviceCDS;
PLT_Service* serviceCMR;
NPT_String type;
type = "urn:schemas-upnp-org:service:ContentDirectory:1";
if (NPT_FAILED(device->FindServiceByType(type, serviceCDS))) {
NPT_LOG_WARNING_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
}
type = "urn:schemas-upnp-org:service:ConnectionManager:1";
if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
NPT_LOG_WARNING_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
}
{
NPT_AutoLock lock(m_MediaServers);
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) is already in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE("Device Found:");
device->ToLog(NPT_LOG_LEVEL_FINE);
m_MediaServers.Add(device);
}
if (m_Listener) {
m_Listener->OnMSAddedRemoved(device, 1);
}
m_CtrlPoint->Subscribe(serviceCDS);
m_CtrlPoint->Subscribe(serviceCMR);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_DeviceData::FindEmbeddedDevice
+---------------------------------------------------------------------*/
NPT_Result
PLT_DeviceData::FindEmbeddedDevice(const char* uuid,
PLT_DeviceDataReference& device)
{
NPT_Result res = NPT_ContainerFind(m_EmbeddedDevices,
PLT_DeviceDataFinder(uuid),
device);
if (NPT_SUCCEEDED(res)) return res;
for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
res = m_EmbeddedDevices[i]->FindEmbeddedDevice(
uuid,
device);
if (NPT_SUCCEEDED(res)) return res;
}
return NPT_FAILURE;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnEventNotify
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnEventNotify(PLT_Service* service, NPT_List<PLT_StateVariable*>* vars)
{
PLT_DeviceDataReference data;
{
NPT_AutoLock lock(m_MediaServers);
NPT_String uuid = service->GetDevice()->GetUUID();
if (NPT_FAILED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) not found in our list!", (const char*)uuid);
return NPT_FAILURE;
}
}
if (m_Listener) m_Listener->OnMSStateVariablesChanged(service, vars);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaController::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaController::OnDeviceAdded(PLT_DeviceDataReference& device)
{
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaRenderers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_FINE_1("Device (%s) is already in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE("Device Found:");
device->ToLog(NPT_LOG_LEVEL_FINE);
// verify the device implements the function we need
PLT_Service* serviceAVT;
PLT_Service* serviceCMR;
NPT_String type;
type = "urn:schemas-upnp-org:service:AVTransport:1";
if (NPT_FAILED(device->FindServiceByType(type, serviceAVT))) {
NPT_LOG_FINE_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
}
type = "urn:schemas-upnp-org:service:ConnectionManager:1";
if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
NPT_LOG_FINE_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
}
m_MediaRenderers.Add(device);
if (m_Listener) {
m_Listener->OnMRAddedRemoved(device, 1);
}
// subscribe to AVT eventing
m_CtrlPoint->Subscribe(serviceAVT);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnActionResponse
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnActionResponse(NPT_Result res, PLT_ActionReference& action, void* userdata)
{
PLT_DeviceDataReference device;
{
NPT_AutoLock lock(m_MediaServers);
NPT_String uuid = action->GetActionDesc()->GetService()->GetDevice()->GetUUID();
if (NPT_FAILED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), device))) {
NPT_LOG_WARNING_1("Device (%s) not found in our list of servers", (const char*)uuid);
return NPT_FAILURE;
}
}
NPT_String actionName = action->GetActionDesc()->GetName();
// Browse action response
if (actionName.Compare("Browse", true) == 0) {
return OnBrowseResponse(res, device, action, userdata);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaController::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaController::OnDeviceAdded(PLT_DeviceDataReference& device)
{
// verify the device implements the function we need
PLT_Service* serviceAVT = NULL;
PLT_Service* serviceCMR;
PLT_Service* serviceRC;
NPT_String type;
if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaRenderer"))
return NPT_FAILURE;
// optional service
type = "urn:schemas-upnp-org:service:AVTransport:*";
if (NPT_SUCCEEDED(device->FindServiceByType(type, serviceAVT))) {
// in case it's a newer upnp implementation, force to 1
NPT_LOG_FINE_1("Service %s found", (const char*)type);
serviceAVT->ForceVersion(1);
}
// required services
type = "urn:schemas-upnp-org:service:ConnectionManager:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
NPT_LOG_FINE_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceCMR->ForceVersion(1);
}
type = "urn:schemas-upnp-org:service:RenderingControl:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceRC))) {
NPT_LOG_FINE_1("Service %s not found", (const char*)type);
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceRC->ForceVersion(1);
}
{
NPT_AutoLock lock(m_MediaRenderers);
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaRenderers,
PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) is already in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE_1("Device Found: %s", (const char*)*device);
m_MediaRenderers.Add(device);
}
if (m_Delegate && m_Delegate->OnMRAdded(device)) {
// subscribe to services eventing only if delegate wants it
if (serviceAVT) m_CtrlPoint->Subscribe(serviceAVT);
// subscribe to required services
m_CtrlPoint->Subscribe(serviceCMR);
m_CtrlPoint->Subscribe(serviceRC);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| CMediaCrawler::OnBrowseDevice
+---------------------------------------------------------------------*/
NPT_Result
CMediaCrawler::OnBrowseDevice(PLT_ActionReference& action,
const char* server_uuid,
const char* server_object_id,
NPT_SocketInfo* info /* = NULL */)
{
NPT_Result res;
PLT_DeviceDataReference device;
{
// look for device first
const NPT_Lock<PLT_DeviceDataReferenceList>& devices = GetMediaServers();
//NPT_AutoLock lock(devices);
if (NPT_FAILED(NPT_ContainerFind(devices, PLT_DeviceDataFinder(server_uuid), device))) {
/* error */
NPT_LOG_WARNING("CMediaCrawler::OnBrowseDevice - device not found.");
action->SetError(701, "No Such Object.");
return NPT_FAILURE;
}
}
// look for args and convert them
NPT_String browseFlagValue;
NPT_String startingInd;
NPT_String reqCount;
NPT_String filter;
NPT_String sort;
NPT_CHECK_SEVERE(action->GetArgumentValue("BrowseFlag", browseFlagValue));
NPT_CHECK_SEVERE(action->GetArgumentValue("StartingIndex", startingInd));
NPT_CHECK_SEVERE(action->GetArgumentValue("RequestedCount", reqCount));
NPT_CHECK_SEVERE(action->GetArgumentValue("Filter", filter));
NPT_CHECK_SEVERE(action->GetArgumentValue("SortCriteria", sort));
unsigned long start_index, req_count;
if (NPT_FAILED(startingInd.ToInteger(start_index)) ||
NPT_FAILED(reqCount.ToInteger(req_count))) {
return NPT_FAILURE;
}
// create a container for our result
// this will be filled in by OnBrowseResponse
CMediaCrawlerBrowseInfoReference browse_info(new CMediaCrawlerBrowseInfo());
browse_info->shared_var.SetValue(0);
// send off the browse packet. Note that this will
// not block. The shared variable is used to block
// until the response has been received.
res = Browse(device,
server_object_id,
start_index,
req_count,
(browseFlagValue == "BrowseMetadata")?1:0,
filter,
sort,
new CMediaCrawlerBrowseInfoReference(browse_info));
NPT_CHECK_SEVERE(res);
// wait 30 secs for response
res = browse_info->shared_var.WaitUntilEquals(1, 30000);
NPT_CHECK_SEVERE(res);
// did the browse fail?
if (NPT_FAILED(browse_info->res)) {
action->SetError(browse_info->code, "");
return NPT_FAILURE;
}
action->SetArgumentValue("Result", UpdateDidl(server_uuid, browse_info->didl, info));
action->SetArgumentValue("NumberReturned", browse_info->nr);
action->SetArgumentValue("TotalMatches", browse_info->tm);
action->SetArgumentValue("UpdateId", browse_info->uid);
action->SetArgumentValue("ObjectID", FormatObjectId(server_uuid, browse_info->object_id));
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MediaController::OnActionResponse
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaController::OnActionResponse(NPT_Result res, PLT_ActionReference& action, void* userdata)
{
if (m_Listener == NULL) {
return NPT_SUCCESS;
}
/* make sure device is a renderer we've previously found */
PLT_DeviceDataReference device;
NPT_String uuid = action->GetActionDesc()->GetService()->GetDevice()->GetUUID();
if (NPT_FAILED(NPT_ContainerFind(m_MediaRenderers, PLT_DeviceDataFinder(uuid), device))) {
NPT_LOG_FINE_1("Device (%s) not found in our list of renderers", (const char*)uuid);
res = NPT_FAILURE;
}
/* extract action name */
NPT_String actionName = action->GetActionDesc()->GetName();
/* AVTransport response ? */
if (actionName.Compare("GetCurrentTransportActions", true) == 0) {
return OnGetCurrentTransportActionsResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetDeviceCapabilities", true) == 0) {
return OnGetDeviceCapabilitiesResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetMediaInfo", true) == 0) {
return OnGetMediaInfoResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetPositionInfo", true) == 0) {
return OnGetPositionInfoResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetTransportInfo", true) == 0) {
return OnGetTransportInfoResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetTransportSettings", true) == 0) {
return OnGetTransportSettingsResponse(res, device, action, userdata);
}
else if (actionName.Compare("Next", true) == 0) {
m_Listener->OnNextResult(res, device, userdata);
}
else if (actionName.Compare("Pause", true) == 0) {
m_Listener->OnPauseResult(res, device, userdata);
}
else if (actionName.Compare("Play", true) == 0) {
m_Listener->OnPlayResult(res, device, userdata);
}
else if (actionName.Compare("Previous", true) == 0) {
m_Listener->OnPreviousResult(res, device, userdata);
}
else if (actionName.Compare("Seek", true) == 0) {
m_Listener->OnSeekResult(res, device, userdata);
}
else if (actionName.Compare("SetAVTransportURI", true) == 0) {
m_Listener->OnSetAVTransportURIResult(res, device, userdata);
}
else if (actionName.Compare("SetPlayMode", true) == 0) {
m_Listener->OnSetPlayModeResult(res, device, userdata);
}
else if (actionName.Compare("Stop", true) == 0) {
m_Listener->OnStopResult(res, device, userdata);
}
else if (actionName.Compare("GetCurrentConnectionIDs", true) == 0) {
return OnGetCurrentConnectionIDsResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetCurrentConnectionInfo", true) == 0) {
return OnGetCurrentConnectionInfoResponse(res, device, action, userdata);
}
else if (actionName.Compare("GetProtocolInfo", true) == 0) {
return OnGetProtocolInfoResponse(res, device, action, userdata);
}
return NPT_SUCCESS;
}
