org.fourthline.cling.model.ValidationException Java Examples

public Device build(Device prototype, UDAVersion deviceVersion, URL baseURL) throws ValidationException {

        List<Device> embeddedDevicesList = new ArrayList();
        for (MutableDevice embeddedDevice : embeddedDevices) {
            embeddedDevicesList.add(embeddedDevice.build(prototype, deviceVersion, baseURL));
        }
        return prototype.newInstance(
                udn,
                deviceVersion,
                createDeviceType(),
                createDeviceDetails(baseURL),
                createIcons(),
                createServices(prototype),
                embeddedDevicesList
        );
    }
 

public Device build(Device prototype, UDAVersion deviceVersion, URL baseURL) throws ValidationException {

        List<Device> embeddedDevicesList = new ArrayList();
        for (MutableDevice embeddedDevice : embeddedDevices) {
            embeddedDevicesList.add(embeddedDevice.build(prototype, deviceVersion, baseURL));
        }
        return prototype.newInstance(
                udn,
                deviceVersion,
                createDeviceType(),
                createDeviceDetails(baseURL),
                createIcons(),
                createServices(prototype),
                embeddedDevicesList
        );
    }
 

private LocalDevice createDevice()
        throws ValidationException, LocalServiceBindingException, IOException {

    DeviceIdentity identity =
            new DeviceIdentity(
                    UDN.uniqueSystemIdentifier(SmartApplianceEnabler.class.getSimpleName())
            );

    DeviceType type = new SmartApplianceEnablerDeviceType();

    DeviceDetails details =
            new DeviceDetails(
                    SmartApplianceEnabler.class.getSimpleName(),
                    new ManufacturerDetails(SmartApplianceEnabler.MANUFACTURER_NAME, URI.create(SmartApplianceEnabler.MANUFACTURER_URI)),
                    new ModelDetails(
                            SmartApplianceEnabler.class.getSimpleName(),
                            SmartApplianceEnabler.DESCRIPTION,
                            SmartApplianceEnabler.VERSION,
                            URI.create(SmartApplianceEnabler.MODEL_URI)
                    )
            );

    return new LocalDevice(identity, type, details, (Icon) null, (LocalService) null);
}
 

public LocalService read(Class<?> clazz, ServiceId id, ServiceType type,
                               boolean supportsQueryStateVariables, Set<Class> stringConvertibleTypes)
        throws LocalServiceBindingException {

    Map<StateVariable, StateVariableAccessor> stateVariables = readStateVariables(clazz, stringConvertibleTypes);
    Map<Action, ActionExecutor> actions = readActions(clazz, stateVariables, stringConvertibleTypes);

    // Special treatment of the state variable querying action
    if (supportsQueryStateVariables) {
        actions.put(new QueryStateVariableAction(), new QueryStateVariableExecutor());
    }

    try {
        return new LocalService(type, id, actions, stateVariables, stringConvertibleTypes, supportsQueryStateVariables);

    } catch (ValidationException ex) {
        log.severe("Could not validate device model: " + ex.toString());
        for (ValidationError validationError : ex.getErrors()) {
            log.severe(validationError.toString());
        }
        throw new LocalServiceBindingException("Validation of model failed, check the log");
    }
}
 

public Service(ServiceType serviceType, ServiceId serviceId,
               Action<S>[] actions, StateVariable<S>[] stateVariables) throws ValidationException {

    this.serviceType = serviceType;
    this.serviceId = serviceId;

    if (actions != null) {
        for (Action action : actions) {
            this.actions.put(action.getName(), action);
            action.setService(this);
        }
    }

    if (stateVariables != null) {
        for (StateVariable stateVariable : stateVariables) {
            this.stateVariables.put(stateVariable.getName(), stateVariable);
            stateVariable.setService(this);
        }
    }

}
 

public Service[] createServices(Device prototype) throws ValidationException {
    Service[] services = prototype.newServiceArray(this.services.size());
    int i = 0;
    for (MutableService service : this.services) {
        services[i++] = service.build(prototype);
    }
    return services;
}
 

public Service[] createServices(Device prototype) throws ValidationException {
    Service[] services = prototype.newServiceArray(this.services.size());
    int i = 0;
    for (MutableService service : this.services) {
        services[i++] = service.build(prototype);
    }
    return services;
}
 

public Service build(Device prototype) throws ValidationException {
    return prototype.newInstance(
            serviceType, serviceId,
            descriptorURI, controlURI, eventSubscriptionURI,
            createActions(),
            createStateVariables()
    );
}
 

@Override
public LocalDevice newInstance(UDN udn, UDAVersion version, DeviceType type, DeviceDetails details,
                               Icon[] icons, LocalService[] services, List<LocalDevice> embeddedDevices)
        throws ValidationException {
    return new LocalDevice(
            new DeviceIdentity(udn, getIdentity().getMaxAgeSeconds()),
            version, type, details, icons,
            services,
            embeddedDevices.size() > 0 ? embeddedDevices.toArray(new LocalDevice[embeddedDevices.size()]) : null
    );
}
 

@Override
public LocalService newInstance(ServiceType serviceType, ServiceId serviceId,
                                URI descriptorURI, URI controlURI, URI eventSubscriptionURI,
                                Action<LocalService>[] actions, StateVariable<LocalService>[] stateVariables) throws ValidationException {
    return new LocalService(
            serviceType, serviceId,
            actions, stateVariables
    );
}
 

public RemoteService(ServiceType serviceType, ServiceId serviceId,
                     URI descriptorURI, URI controlURI, URI eventSubscriptionURI,
                     Action<RemoteService>[] actions, StateVariable<RemoteService>[] stateVariables) throws ValidationException {
    super(serviceType, serviceId, actions, stateVariables);

    this.descriptorURI = descriptorURI;
    this.controlURI = controlURI;
    this.eventSubscriptionURI = eventSubscriptionURI;

    List<ValidationError> errors = validateThis();
    if (errors.size() > 0) {
        throw new ValidationException("Validation of device graph failed, call getErrors() on exception", errors);
    }
}
 

@Override
public RemoteDevice newInstance(UDN udn, UDAVersion version, DeviceType type, DeviceDetails details,
                                Icon[] icons, RemoteService[] services,
                                List<RemoteDevice> embeddedDevices) throws ValidationException {
    return new RemoteDevice(
            new RemoteDeviceIdentity(udn, getIdentity()),
            version, type, details, icons,
            services,
            embeddedDevices.size() > 0 ? embeddedDevices.toArray(new RemoteDevice[embeddedDevices.size()]) : null
    );
}
 

Resource[] getResources(Device device) throws RegistrationException {
    try {
        return registry.getConfiguration().getNamespace().getResources(device);
    } catch (ValidationException ex) {
        throw new RegistrationException("Resource discover error: " + ex.toString(), ex);
    }
}
 

@Override
public RemoteService newInstance(ServiceType serviceType, ServiceId serviceId,
                                 URI descriptorURI, URI controlURI, URI eventSubscriptionURI,
                                 Action<RemoteService>[] actions, StateVariable<RemoteService>[] stateVariables) throws ValidationException {
    return new RemoteService(
            serviceType, serviceId,
            descriptorURI, controlURI, eventSubscriptionURI,
            actions, stateVariables
    );
}
 

@Override
public LocalDevice newInstance(UDN udn, UDAVersion version, DeviceType type, DeviceDetails details,
                               Icon[] icons, LocalService[] services, List<LocalDevice> embeddedDevices)
        throws ValidationException {
    return new LocalDevice(
            new DeviceIdentity(udn, getIdentity().getMaxAgeSeconds()),
            version, type, details, icons,
            services,
            embeddedDevices.size() > 0 ? embeddedDevices.toArray(new LocalDevice[embeddedDevices.size()]) : null
    );
}
 

public MediaServer(Context context ) throws ValidationException {
    mContext = context;
    DeviceType type = new UDADeviceType(deviceType, version);

    DeviceDetails details = new DeviceDetails(SettingActivity.getDeviceName(context) + " ("
            + android.os.Build.MODEL + ")", new ManufacturerDetails(
            android.os.Build.MANUFACTURER), new ModelDetails(android.os.Build.MODEL,
            Utils.DMS_DESC, "v1"));

    LocalService service = new AnnotationLocalServiceBinder()
            .read(ContentDirectoryService.class);

    service.setManager(new DefaultServiceManager<ContentDirectoryService>(service,
            ContentDirectoryService.class));

    udn = UpnpUtil.uniqueSystemIdentifier("msidms");

    localDevice = new LocalDevice(new DeviceIdentity(udn), type, details, createDefaultDeviceIcon(), service);

    Log.v(LOGTAG, "MediaServer device created: ");
    Log.v(LOGTAG, "friendly name: " + details.getFriendlyName());
    Log.v(LOGTAG, "manufacturer: " + details.getManufacturerDetails().getManufacturer());
    Log.v(LOGTAG, "model: " + details.getModelDetails().getModelName());

    // start http server
    try {
        new HttpServer(PORT);
    } catch (IOException ioe) {
        System.err.println("Couldn't start server:\n" + ioe);
        System.exit(-1);
    }

    Log.v(LOGTAG, "Started Http Server on port " + PORT);
}
 

@Override
public LocalService newInstance(ServiceType serviceType, ServiceId serviceId,
                                URI descriptorURI, URI controlURI, URI eventSubscriptionURI,
                                Action<LocalService>[] actions, StateVariable<LocalService>[] stateVariables) throws ValidationException {
    return new LocalService(
            serviceType, serviceId,
            actions, stateVariables
    );
}
 

@Override
public RemoteService newInstance(ServiceType serviceType, ServiceId serviceId,
                                 URI descriptorURI, URI controlURI, URI eventSubscriptionURI,
                                 Action<RemoteService>[] actions, StateVariable<RemoteService>[] stateVariables) throws ValidationException {
    return new RemoteService(
            serviceType, serviceId,
            descriptorURI, controlURI, eventSubscriptionURI,
            actions, stateVariables
    );
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon icon, LocalService[] services, LocalDevice[] embeddedDevices) throws ValidationException {
    super(identity, type, details, new Icon[]{icon}, services, embeddedDevices);
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon icon, LocalService service, LocalDevice embeddedDevice) throws ValidationException {
    super(identity, type, details, new Icon[]{icon}, new LocalService[]{service}, new LocalDevice[]{embeddedDevice});
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon icon, LocalService service) throws ValidationException {
    super(identity, type, details, new Icon[]{icon}, new LocalService[]{service});
    this.deviceDetailsProvider = null;
}
 

public RemoteDevice(RemoteDeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon[] icons, RemoteService[] services) throws ValidationException {
    super(identity, type, details, icons, services);
}
 

public abstract D newInstance(UDN udn, UDAVersion version, DeviceType type, DeviceDetails details,
Icon[] icons, S[] services, List<D> embeddedDevices) throws ValidationException;
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetailsProvider deviceDetailsProvider,
                   Icon[] icons, LocalService service, LocalDevice embeddedDevice) throws ValidationException {
    super(identity, type, null, icons, new LocalService[]{service}, new LocalDevice[]{embeddedDevice});
    this.deviceDetailsProvider = deviceDetailsProvider;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon[] icons, LocalService[] services) throws ValidationException {
    super(identity, type, details, icons, services);
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon[] icons, LocalService[] services, LocalDevice[] embeddedDevices) throws ValidationException {
    super(identity, type, details, icons, services, embeddedDevices);
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, UDAVersion version, DeviceType type, DeviceDetails details,
                   Icon[] icons, LocalService[] services, LocalDevice[] embeddedDevices) throws ValidationException {
    super(identity, version, type, details, icons, services, embeddedDevices);
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, UDAVersion version, DeviceType type, DeviceDetailsProvider deviceDetailsProvider,
                   Icon[] icons, LocalService[] services, LocalDevice[] embeddedDevices) throws ValidationException {
    super(identity, version, type, null, icons, services, embeddedDevices);
    this.deviceDetailsProvider = deviceDetailsProvider;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   LocalService[] services) throws ValidationException {
    super(identity, type, details, null, services);
    this.deviceDetailsProvider = null;
}
 

public LocalDevice(DeviceIdentity identity, DeviceType type, DeviceDetails details,
                   Icon[] icons, LocalService service, LocalDevice embeddedDevice) throws ValidationException {
    super(identity, type, details, icons, new LocalService[]{service}, new LocalDevice[]{embeddedDevice});
    this.deviceDetailsProvider = null;
}