RuleWizardAlfClientPage::RuleWizardAlfClientPage(wxWindow *parent,
RuleWizardHistory *history) : RuleWizardAlfPermissionPageBase(parent)
{
history->get();
history_ = history;
switch (history_->getAlfClientPermission()) {
case RuleWizardHistory::PERM_ALLOW_ALL:
yesRadioButton->SetValue(true);
break;
case RuleWizardHistory::PERM_RESTRICT_DEFAULT:
defaultRadioButton->SetValue(true);
break;
case RuleWizardHistory::PERM_RESTRICT_USER:
restrictedRadioButton->SetValue(true);
break;
case RuleWizardHistory::PERM_DENY_ALL:
/* FALLTHROUGH */
default:
noRadioButton->SetValue(true);
break;
}
ServiceList *serviceList = history_->getAlfClientPortList();
defaultRadioButton->Enable(serviceList->canHaveDefaultServices());
defaultLabel->Enable(serviceList->canHaveDefaultServices());
parent->Connect(wxEVT_WIZARD_PAGE_CHANGED,
wxWizardEventHandler(RuleWizardAlfClientPage::onPageChanged),
NULL, this);
}
TVDevice::TVDevice()
{
//////////////////////////////////////
// Control Ponit
//////////////////////////////////////
ctrlPoint = new ControlPoint();
ctrlPoint->addNotifyListener(this);
ctrlPoint->addSearchResponseListener(this);
ctrlPoint->addEventListener(this);
//////////////////////////////////////
// Device
//////////////////////////////////////
try {
tvDev = new Device(DESCRIPTION_FILE_NAME);
Action *getPowerAction = tvDev->getAction("GetPower");
getPowerAction->setActionListener(this);
Action *setPowerAction = tvDev->getAction("SetPower");
setPowerAction->setActionListener(this);
ServiceList *serviceList = tvDev->getServiceList();
Service *service = serviceList->getService(0);
service->setQueryListener(this);
}
catch (InvalidDescriptionException e) {
cerr << e.getMessage() << endl;
}
}
void
show_all(ServiceList& service_list)
{
map<string, GenericService*>::const_iterator service_iterator =
service_list.services_by_name().begin();
map<string, GenericService*>::const_iterator service_iterator_end =
service_list.services_by_name().end();
for (; service_iterator != service_iterator_end; service_iterator++)
{
cout << " " << service_iterator->first << ", ID: " <<
service_iterator->second->get_id() << ", Type: " <<
service_iterator->second->get_data_type_name() << ", Value: ";
if (service_iterator->second->get_data_type_name() == typeid(std::string("")).name())
{
cout << static_cast< Service<std::string>* >(service_iterator->second)->publish();
} else if (service_iterator->second->get_data_type_name() == typeid(int(0)).name())
{
cout << static_cast< Service<int>* >(service_iterator->second)->publish();
} else if (service_iterator->second->get_data_type_name() == typeid(double(0)).name())
{
cout << static_cast< Service<double>* >(service_iterator->second)->publish();
} else
{
cout << "UNKNOWN TYPE";
}
cout << "\n";
}
}
void ModuleManager::AddServices(const ServiceList& list)
{
for (ServiceList::const_iterator i = list.begin(); i != list.end(); ++i)
{
ServiceProvider& s = **i;
AddService(s);
}
}
void PrintDeviceInfo(Device *dev, int indent)
{
string indentStr;
GetIndentString(indent, indentStr);
const char *devName = dev->getFriendlyName();
cout << indentStr << devName << endl;
int i, n, j;
ServiceList *serviceList = dev->getServiceList();
int serviceCnt = serviceList->size();
for (n=0; n<serviceCnt; n++) {
Service *service = serviceList->getService(n);
cout << indentStr << " service[" << n << "] = "<< service->getServiceType() << endl;
ActionList *actionList = service->getActionList();
int actionCnt = actionList->size();
for (i=0; i<actionCnt; i++) {
Action *action = actionList->getAction(i);
cout << indentStr << " action[" << i << "] = "<< action->getName() << endl;
ArgumentList *argList = action->getArgumentList();
int argCnt = argList->size();
for (j=0; j<argCnt; j++) {
Argument *arg = argList->getArgument(j);
cout << indentStr << " arg[" << j << "] = " << arg->getName() << "(" << arg->getDirection() << ")";
StateVariable *stateVar = arg->getRelatedStateVariable();
if (stateVar != NULL)
cout << " - " << stateVar->getName();
cout << endl;
}
}
ServiceStateTable *stateTable = service->getServiceStateTable();
int varCnt = stateTable->size();
for (i=0; i<varCnt; i++) {
StateVariable *stateVar = stateTable->getStateVariable(i);
cout << indentStr << " stateVar[" << i << "] = " << stateVar->getName() << endl;
AllowedValueList *valueList = stateVar->getAllowedValueList();
int valueListCnt = valueList->size();
if (0 < valueListCnt) {
for (j=0; j<valueListCnt; j++)
cout << indentStr << " AllowedValueList[" << j << "] = " << valueList->getAllowedValue(j) << endl;
}
AllowedValueRange *valueRange = stateVar->getAllowedValueRange();
if (valueRange != NULL) {
cout << indentStr << " AllowedRange[minimum] = " << valueRange->getMinimum() << endl;
cout << indentStr << " AllowedRange[maximum] = " << valueRange->getMaximum() << endl;
cout << indentStr << " AllowedRange[step] = " << valueRange->getStep() << endl;
}
}
}
}
ServiceList
DistQuery::cachedServices()
{
std::list<bp::service::Summary> cached = PendingUpdateCache::cached();
std::list<bp::service::Summary>::iterator it;
ServiceList lst;
for (it = cached.begin(); it != cached.end(); it++)
{
lst.push_back(
std::pair<std::string, std::string>(it->name(), it->version()));
}
return lst;
}
TestDevice::TestDevice()
{
loadDescription(DEVICE_DESCRIPTION);
Service *counterService = getService("urn:schemas-upnp-org:service:count:1");
counterService->loadSCPD(SERVICE_DESCRIPTION);
Action *getCountAction = getAction("GetCount");
getCountAction->setActionListener(this);
Action *setCountAction = getAction("SetCount");
setCountAction->setActionListener(this);
ServiceList *serviceList = getServiceList();
Service *service = serviceList->getService(0);
service->setQueryListener(this);
}
void ControlPoint::unsubscribe(Device *device) {
int n;
ServiceList *serviceList = device->getServiceList();
int serviceCnt = serviceList->size();
for (n = 0; n < serviceCnt; n++) {
Service *service = serviceList->getService(n);
if (service->hasSID() == true)
unsubscribe(service);
}
DeviceList *childDevList = device->getDeviceList();
int childDevCnt = childDevList->size();
for (n = 0; n < childDevCnt; n++) {
Device *cdev = childDevList->getDevice(n);
unsubscribe(cdev);
}
}
void ControlPoint::renewSubscriberService(Device *dev, long timeout) {
int n;
ServiceList *serviceList = dev->getServiceList();
int serviceCnt = serviceList->size();
for (n = 0; n < serviceCnt; n++) {
Service *service = serviceList->getService(n);
if (service->isSubscribed() == false)
continue;
const char *sid = service->getSID();
bool isRenewed = subscribe(service, sid, timeout);
if (isRenewed == false)
subscribe(service, timeout);
}
DeviceList *cdevList = dev->getDeviceList();
int cdevCnt = cdevList->size();
for (n = 0; n < cdevCnt; n++) {
Device *cdev = cdevList->getDevice(n);
renewSubscriberService(cdev, timeout);
}
}
ClockDevice::ClockDevice() : Device(CLOCK_DESCRIPTION_FILE_NAME)
#else
ClockDevice::ClockDevice() : Device()
#endif
{
#if !defined(USE_CLOCK_DESCRIPTION_FILE)
loadDescription(CLOCK_DEVICE_DESCRIPTION);
Service *timeService = getService("urn:schemas-upnp-org:service:timer:1");
timeService->loadSCPD(CLOCK_SERVICE_DESCRIPTION);
#endif
Action *getTimeAction = getAction("GetTime");
getTimeAction->setActionListener(this);
Action *setTimeAction = getAction("SetTime");
setTimeAction->setActionListener(this);
ServiceList *serviceList = getServiceList();
Service *service = serviceList->getService(0);
service->setQueryListener(this);
m_timeVar = getStateVariable("Time");
setLeaseTime(60);
}
////////////////////////////////////////////////
// ActionListener
////////////////////////////////////////////////
bool ClockDevice::actionControlReceived(Action *action)
{
const char *actionName = action->getName();
if (strcmp("GetTime", actionName) == 0) {
std::string dateStr;
Clock clock;
clock.toString(dateStr);
Argument *timeArg = action->getArgument("CurrentTime");
timeArg->setValue(dateStr.c_str());
return true;
}
if (strcmp(actionName, "SetTime") == 0) {
Argument *timeArg = action->getArgument("NewTime");
const char *newTime = timeArg->getValue();
Argument *resultArg = action->getArgument("Result");
std::ostringstream valbuf;
valbuf << "Not implemented (" << newTime << ")";
resultArg->setValue(valbuf.str().c_str());
return true;
}
return false;
}
////////////////////////////////////////////////
// QueryListener
////////////////////////////////////////////////
bool ClockDevice::queryControlReceived(StateVariable *stateVar)
{
const char *varName = stateVar->getName();
Clock clock;
string clockVal;
stateVar->setValue(clock.toString(clockVal));
return true;
}
////////////////////////////////////////////////
// HttpRequestListner
////////////////////////////////////////////////
//void ClockDevice::httpRequestRecieved(HTTPRequest *httpReq)
HTTP::StatusCode ClockDevice::httpRequestRecieved(HTTPRequest *httpReq)
{
ParameterList paramList;
httpReq->getParameterList(paramList);
for (int n=0; n<paramList.size(); n++) {
Parameter *param = paramList.getParameter(n);
cout << "[" << n << "] : " << param->getName() << " = " << param->getValue() << endl;
}
string uri;
httpReq->getURI(uri);
if (uri.find(CLOCK_PRESENTATION_URI) == string::npos) {
Device::httpRequestRecieved(httpReq);
return HTTP::OK_REQUEST;
//return ;
}
string clockStr;
Clock clock;
clock.toString(clockStr);
string contents;
contents = "<HTML><BODY><H1>";
contents += clockStr;
contents += "</H1></BODY></HTML>";
HTTPResponse httpRes;
httpRes.setStatusCode(HTTP::OK_REQUEST);
httpRes.setContent(contents);
return httpReq->post(&httpRes) ? HTTP::OK_REQUEST : HTTP::INTERNAL_SERVER_ERROR;
}
