/*----------------------------------------------------------------------
| Test1
+---------------------------------------------------------------------*/
static bool
Test1(PLT_TaskManager* task_manager, const char* url, NPT_Size& size)
{
NPT_LOG_INFO("########### TEST 1 ######################");
NPT_MemoryStreamReference memory_stream(new NPT_MemoryStream());
NPT_OutputStreamReference output_stream(memory_stream);
PLT_Downloader downloader(task_manager, url, output_stream);
downloader.Start();
while (1) {
switch(downloader.GetState()) {
case PLT_DOWNLOADER_SUCCESS: {
size = memory_stream->GetDataSize();
return true;
}
case PLT_DOWNLOADER_ERROR:
return false;
default:
NPT_System::Sleep(NPT_TimeInterval(0, 10000));
break;
}
};
return false;
}
/*----------------------------------------------------------------------
| PLT_UPnP::Start()
+---------------------------------------------------------------------*/
NPT_Result
PLT_UPnP::Start()
{
NPT_LOG_INFO("Starting UPnP...");
NPT_AutoLock lock(m_Lock);
if (m_Started == true) NPT_CHECK_SEVERE(NPT_ERROR_INVALID_STATE);
NPT_List<NPT_IpAddress> ips;
PLT_UPnPMessageHelper::GetIPAddresses(ips);
/* Create multicast socket and bind on 1900. If other apps didn't
play nicely by setting the REUSE_ADDR flag, this could fail */
NPT_UdpMulticastSocket* socket = new NPT_UdpMulticastSocket();
NPT_CHECK_SEVERE(socket->Bind(NPT_SocketAddress(NPT_IpAddress::Any, 1900), true));
/* Join multicast group for every ip we found */
NPT_CHECK_SEVERE(ips.ApplyUntil(PLT_SsdpInitMulticastIterator(socket),
NPT_UntilResultNotEquals(NPT_SUCCESS)));
/* create the ssdp listener */
m_SsdpListenTask = new PLT_SsdpListenTask(socket);
NPT_CHECK_SEVERE(m_TaskManager.StartTask(m_SsdpListenTask));
/* start devices & ctrlpoints */
// TODO: Starting devices and ctrlpoints could fail?
m_CtrlPoints.Apply(PLT_UPnP_CtrlPointStartIterator(m_SsdpListenTask));
m_Devices.Apply(PLT_UPnP_DeviceStartIterator(m_SsdpListenTask));
m_Started = true;
return NPT_SUCCESS;
}
/*
* Class: com_plutinosoft_platinum_UPnP
* Method: _stop
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_com_plutinosoft_platinum_UPnP__1stop(JNIEnv *, jclass, jlong _self)
{
NPT_LOG_INFO("stop");
PLT_UPnP* self = (PLT_UPnP*)_self;
return self->Stop();
}
/*----------------------------------------------------------------------
| Test3
+---------------------------------------------------------------------*/
static bool
Test3(PLT_TaskManager* task_manager, NPT_HttpUrl url, PLT_RingBufferStreamReference& ringbuffer_stream, NPT_Size& size)
{
NPT_LOG_INFO("########### TEST 3 ######################");
/* reset output param first */
size = 0;
NPT_MemoryStreamReference memory_stream(new NPT_MemoryStream());
NPT_OutputStreamReference output_stream(memory_stream);
PLT_Downloader downloader(task_manager, url, output_stream);
downloader.Start();
/* asynchronously write onto ring buffer stream */
task_manager->StartTask(new RingBufferWriterTask(ringbuffer_stream));
/* start pulling data */
while (1) {
switch(downloader.GetState()) {
case PLT_DOWNLOADER_SUCCESS:
size = memory_stream->GetDataSize();
return true;
case PLT_DOWNLOADER_ERROR:
return false;
default:
NPT_System::Sleep(NPT_TimeInterval(.1f));
break;
}
};
return false;
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int
main(int, char**)
{
NPT_LogManager::GetDefault().Configure("plist:.level=ALL;");
NPT_LOG_L(MyLogger, NPT_LOG_LEVEL_WARNING, "blabla");
NPT_LOG_L2(MyLogger, NPT_LOG_LEVEL_WARNING, "blabla %d %d", 8, 9);
NPT_LOG(NPT_LOG_LEVEL_WARNING, "blibli");
NPT_LOG_2(NPT_LOG_LEVEL_INFO, "fofo %d %d", 5, 7);
NPT_LOG_SEVERE("this is severe!");
NPT_LOG_SEVERE_1("this is severe (%d)", 9);
NPT_LOG_SEVERE_L(MyLogger, "this is severe!");
NPT_LOG_SEVERE_L1(MyLogger, "this is severe (%d)", 9);
NPT_LOG_SEVERE_L(FooLogger, "this is severe!");
NPT_LOG_SEVERE_L1(FooLogger, "this is severe (%d)", 9);
NPT_LOG_SEVERE("severe");
NPT_LOG_WARNING("warning");
NPT_LOG_INFO("info");
NPT_LOG_FINE("fine");
NPT_LOG_FINER("finer");
NPT_LOG_FINEST("finest");
NPT_LOG_SEVERE_L(FooLogger, "severe");
NPT_LOG_WARNING_L(FooLogger, "warning");
NPT_LOG_INFO_L(FooLogger, "info");
NPT_LOG_FINE_L(FooLogger, "fine");
NPT_LOG_FINER_L(FooLogger, "finer");
NPT_LOG_FINEST_L(FooLogger, "finest");
TestLargeBuffer();
TestCheck();
TestCheckSevere();
TestCheckWarning();
TestCheckInfo();
TestCheckFine();
TestCheckFiner();
TestCheckFinest();
TestCheckL();
TestCheckSevereL();
TestCheckWarningL();
TestCheckInfoL();
TestCheckFineL();
TestCheckFinerL();
TestCheckFinestL();
return 0;
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int
main(int /* argc */, char** argv)
{
/* parse command line */
ParseCommandLine(argv+1);
PLT_UPnP upnp(1900, !Options.broadcast);
PLT_DeviceHostReference device(
new PLT_FileMediaServer(
Options.path,
Options.friendly_name?Options.friendly_name:"Platinum UPnP Media Server",
false,
"SAMEDEVICEGUID",
(NPT_UInt16)Options.port)
);
NPT_List<NPT_String> list;
NPT_CHECK_SEVERE(PLT_UPnPMessageHelper::GetIPAddresses(list));
NPT_String ip = *(list.GetFirstItem());
//device->m_PresentationURL = NPT_HttpUrl(ip, 80, "/").ToString();
device->m_ModelDescription = "Platinum File Media Server";
device->m_ModelURL = "http://www.plutinosoft.com/";
device->m_ModelNumber = "1.0";
device->m_ModelName = "Platinum File Media Server";
device->m_Manufacturer = "Plutinosoft";
device->m_ManufacturerURL = "http://www.plutinosoft.com/";
if (Options.broadcast) device->SetBroadcast(true);
upnp.AddDevice(device);
NPT_String uuid = device->GetUUID();
NPT_CHECK_SEVERE(upnp.Start());
NPT_LOG_INFO("Press 'q' to quit.");
char buf[256];
while (gets(buf)) {
if (*buf == 'q')
break;
}
upnp.Stop();
return 0;
}
/*----------------------------------------------------------------------
| Test4
+---------------------------------------------------------------------*/
static bool
Test4(PLT_TaskManager* task_manager, NPT_HttpUrl url, NPT_TimeInterval wait_before_kill)
{
NPT_LOG_INFO("########### TEST 4 ######################");
NPT_HttpClient client;
/* start task to asynchronously fetch url */
ClientStuckTask* task = new ClientStuckTask(url, client);
task_manager->StartTask(task, NULL, false);
/* wait a bit and abort client */
NPT_System::Sleep(wait_before_kill);
task->Kill();
return true;
}
/*----------------------------------------------------------------------
| PLT_UPnP::Stop
+---------------------------------------------------------------------*/
NPT_Result
PLT_UPnP::Stop()
{
NPT_AutoLock lock(m_Lock);
if (m_Started == false) return NPT_FAILURE;
NPT_LOG_INFO("Stopping UPnP...");
// Stop ctrlpoints and devices first
m_CtrlPoints.Apply(PLT_UPnP_CtrlPointStopIterator(m_SsdpListenTask));
m_Devices.Apply(PLT_UPnP_DeviceStopIterator(m_SsdpListenTask));
m_TaskManager.StopAllTasks();
m_SsdpListenTask = NULL;
m_Started = false;
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| Test2
+---------------------------------------------------------------------*/
static bool
Test2(PLT_TaskManager* task_manager, const char* url, NPT_Size& size)
{
NPT_LOG_INFO("########### TEST 2 ######################");
/* reset output param first */
size = 0;
PLT_RingBufferStreamReference ringbuffer_stream(new PLT_RingBufferStream());
NPT_OutputStreamReference output_stream(ringbuffer_stream);
NPT_InputStreamReference input_stream(ringbuffer_stream);
PLT_Downloader downloader(task_manager, url, output_stream);
downloader.Start();
while (1) {
switch(downloader.GetState()) {
case PLT_DOWNLOADER_SUCCESS:
ringbuffer_stream->SetEos();
/* fallthrough */
case PLT_DOWNLOADER_DOWNLOADING: {
NPT_Size bytes_read;
NPT_Result res = ReadBody(downloader, input_stream, bytes_read);
if (NPT_FAILED(res)) {
return (res==NPT_ERROR_EOS)?true:false;
}
size += bytes_read;
}
break;
case PLT_DOWNLOADER_ERROR:
return false;
default:
NPT_System::Sleep(NPT_TimeInterval(0, 10000));
break;
}
};
return false;
}
/*----------------------------------------------------------------------
| PLT_UPnP::AddCtrlPoint
+---------------------------------------------------------------------*/
NPT_Result
PLT_UPnP::AddCtrlPoint(PLT_CtrlPointReference& ctrl_point)
{
NPT_AutoLock lock(m_Lock);
if (m_IgnoreLocalUUIDs) {
for (NPT_List<PLT_DeviceHostReference>::Iterator iter =
m_Devices.GetFirstItem();
iter;
iter++) {
ctrl_point->IgnoreUUID((*iter)->GetUUID());
}
}
if (m_Started) {
NPT_LOG_INFO("Starting Ctrlpoint...");
NPT_CHECK_SEVERE(ctrl_point->Start(m_SsdpListenTask));
}
m_CtrlPoints.Add(ctrl_point);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_UPnP::AddDevice
+---------------------------------------------------------------------*/
NPT_Result
PLT_UPnP::AddDevice(PLT_DeviceHostReference& device)
{
NPT_AutoLock lock(m_Lock);
// tell all our controllers to ignore this device
if (m_IgnoreLocalUUIDs) {
for (NPT_List<PLT_CtrlPointReference>::Iterator iter =
m_CtrlPoints.GetFirstItem();
iter;
iter++) {
(*iter)->IgnoreUUID(device->GetUUID());
}
}
if (m_Started) {
NPT_LOG_INFO("Starting Device...");
NPT_CHECK_SEVERE(device->Start(m_SsdpListenTask));
}
m_Devices.Add(device);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_UPnP::Start()
+---------------------------------------------------------------------*/
NPT_Result
PLT_UPnP::Start()
{
NPT_LOG_INFO("Starting UPnP...");
NPT_AutoLock lock(m_Lock);
if (m_Started == true) return NPT_FAILURE;
NPT_Socket* socket = m_Multicast?new NPT_UdpMulticastSocket(): new NPT_UdpSocket();
NPT_CHECK_SEVERE(socket->Bind(NPT_SocketAddress(NPT_IpAddress::Any, m_Port)));
/* create the ssdp listener */
m_SsdpListenTask = new PLT_SsdpListenTask(socket, m_Multicast, true);
NPT_CHECK_SEVERE(m_TaskManager.StartTask(m_SsdpListenTask));
/* start devices & ctrlpoints */
m_CtrlPoints.Apply(PLT_UPnP_CtrlPointStartIterator(m_SsdpListenTask));
m_Devices.Apply(PLT_UPnP_DeviceStartIterator(m_SsdpListenTask));
m_Started = true;
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| Test3
+---------------------------------------------------------------------*/
static bool
Test3(PLT_TaskManager* task_manager, const char* url, PLT_RingBufferStreamReference& ringbuffer_stream, NPT_Size& size)
{
NPT_LOG_INFO("########### TEST 3 ######################");
/* reset output param first */
size = 0;
NPT_MemoryStreamReference memory_stream(new NPT_MemoryStream());
NPT_OutputStreamReference output_stream(memory_stream);
PLT_Downloader downloader(task_manager, url, output_stream);
downloader.Start();
/* asynchronously write onto ring buffer stream */
char buffer[32768];
ringbuffer_stream->WriteFully(buffer, 32768);
/* mark as done */
ringbuffer_stream->SetEos();
while (1) {
switch(downloader.GetState()) {
case PLT_DOWNLOADER_SUCCESS:
size = memory_stream->GetDataSize();
return true;
case PLT_DOWNLOADER_ERROR:
return false;
default:
NPT_System::Sleep(NPT_TimeInterval(0, 10000));
break;
}
};
return false;
}
/*----------------------------------------------------------------------
| Test5
+---------------------------------------------------------------------*/
static bool
Test5(NPT_HttpUrl url)
{
NPT_LOG_INFO("########### TEST 5 ######################");
NPT_HttpClient client;
// first request
NPT_HttpRequest request(url, NPT_HTTP_METHOD_POST, NPT_HTTP_PROTOCOL_1_1);
NPT_HttpEntity* request_entity = new NPT_HttpEntity();
request_entity->SetInputStream("Testing");
request.SetEntity(request_entity);
NPT_HttpResponse* response = NULL;
client.SendRequest(request, response);
NPT_HttpEntity* entity = NULL;
if (response && (entity = response->GetEntity())) {
NPT_DataBuffer buffer;
if (NPT_FAILED(entity->Load(buffer))) return false;
}
// try again
delete response;
response = NULL;
request_entity = new NPT_HttpEntity();
request_entity->SetInputStream("Testing2");
request.SetEntity(request_entity);
client.SendRequest(request, response);
entity = NULL;
if (response && (entity = response->GetEntity())) {
NPT_DataBuffer buffer;
if (NPT_FAILED(entity->Load(buffer))) return false;
}
return true;
}
/*
* Class: com_plutinosoft_platinum_UPnP
* Method: _init
* Signature: ()J
*/
JNIEXPORT jlong JNICALL Java_com_plutinosoft_platinum_UPnP__1init(JNIEnv *env, jclass)
{
NPT_LOG_INFO("init");
PLT_UPnP* self = new PLT_UPnP();
return (jlong)self;
}
