org.apache.commons.lang.IllegalClassException#org.teleal.cling.model.meta.RemoteDevice源码实例Demo

@Override
public void remoteDeviceAdded(Registry registry, RemoteDevice device) {
    if (device.getType().getNamespace().equals("schemas-upnp-org")
            && device.getType().getType().equals("MediaServer")) {
        if (!found) {
            try {
                if (!TextUtils.isEmpty(device.getDetails().getSerialNumber())) {
                    if (device.getDetails().getSerialNumber().equals(mFileSource.getUpnpSerialNumber())) {
                        startBrowse(device);
                        found = true;
                    }
                } else {
                    if (device.getIdentity().getUdn().toString().equals(mFileSource.getUpnpSerialNumber())) {
                        startBrowse(device);
                        found = true;
                    }
                }
            } catch (Exception e) {}
        }
    }
}
 

@Override
public void remoteDeviceAdded(Registry registry, RemoteDevice device) {
	if (device.getType().getNamespace().equals("schemas-upnp-org")
			&& device.getType().getType().equals("MediaServer")) {
		if (!found) {
			try {
				if (!TextUtils.isEmpty(device.getDetails().getSerialNumber())) {
					if (device.getDetails().getSerialNumber().equals(mFileSource.getUpnpSerialNumber())) {
						startBrowse(device);
						found = true;
					}
				} else {
					if (device.getIdentity().getUdn().toString().equals(mFileSource.getUpnpSerialNumber())) {
						startBrowse(device);
						found = true;
					}
				}
			} catch (Exception e) {}
		}
	}
}
 

@Override
        public void remoteDeviceDiscoveryFailed(Registry registry, final RemoteDevice device, final Exception ex) {
            _hgcontext.runOnUiThread(new Runnable() {
                public void run() {
//                    Toast.makeText(_hgcontext.getApplicationContext(), "UpNP FAILED Discovery: " + device.getDisplayString(), 2000).show();
                }
            });
            deviceRemoved(device);
        }
 

/**
 * @param device the device to set
 */
public void setDevice(RemoteDevice device) {
    this.device = device;
    if (upnpService != null && device != null) {
        isConfigured = true;
        enableGENASubscriptions();
    }
}
 

public SonosZonePlayer getByDevice(RemoteDevice device) {
    if (device != null) {
        Iterator<SonosZonePlayer> it = this.iterator();
        while (it.hasNext()) {
            SonosZonePlayer aPlayer = it.next();
            if (aPlayer.getDevice() != null && aPlayer.getDevice().equals(device)) {
                return aPlayer;
            }
        }
    }
    return null;
}
 

@Override
@SuppressWarnings("rawtypes")
public void remoteDeviceAdded(Registry registry, RemoteDevice device) {

    // add only Sonos devices
    if (device.getDetails().getManufacturerDetails().getManufacturer().toUpperCase().contains("SONOS")) {

        UDN udn = device.getIdentity().getUdn();
        boolean existingDevice = false;

        logger.info("Found a Sonos device ({}) with UDN {}",
                device.getDetails().getModelDetails().getModelNumber(), udn);

        // Check if we already received a configuration for this
        // device through the .cfg
        SonosZonePlayer thePlayer = sonosZonePlayerCache.getByUDN(udn.getIdentifierString());

        if (thePlayer == null) {
            // Add device to the cached Configs
            thePlayer = new SonosZonePlayer(udn.getIdentifierString(), self);
            thePlayer.setUdn(udn);

            sonosZonePlayerCache.add(thePlayer);
        }

        thePlayer.setDevice(device);
        thePlayer.setService(upnpService);
        thePlayer.updateCurrentZoneName();

        // add GENA service to capture zonegroup information
        Service service = device.findService(new UDAServiceId("ZoneGroupTopology"));
        SonosSubscriptionCallback callback = new SonosSubscriptionCallback(service, interval);
        upnpService.getControlPoint().execute(callback);
    } else {
        logger.debug("A non-Sonos device ({}) is found and will be ignored", device.getDisplayString());
    }
}
 

@Override
public void remoteDeviceAdded(Registry registry, RemoteDevice device) {
	if (device.getType().getNamespace().equals("schemas-upnp-org")
			&& device.getType().getType().equals("MediaServer")) {
		deviceAdded(new UpnpDevice(device));
	}
}
 

@Override
public void remoteDeviceDiscoveryStarted(Registry registry, RemoteDevice device) {
    deviceAdded(device);
}
 

@Override
public void remoteDeviceAdded(Registry registry, RemoteDevice device) {
    deviceAdded(device);
}
 

@Override
public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {
    deviceRemoved(device);
}
 

/**
 * @return the device
 */
public RemoteDevice getDevice() {
    return device;
}
 

@Override
public void remoteDeviceDiscoveryStarted(Registry registry, RemoteDevice device) {
    logger.debug("Discovery started: " + device.getDisplayString());
}
 

@Override
public void remoteDeviceDiscoveryFailed(Registry registry, RemoteDevice device, Exception ex) {
    logger.debug("Discovery failed: " + device.getDisplayString() + " => " + ex);
}
 

@Override
public void remoteDeviceUpdated(Registry registry, RemoteDevice device) {
    logger.trace("Remote device updated: " + device.getDisplayString());
}
 

@Override
public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {
    logger.trace("Remote device removed: " + device.getDisplayString());
}
 

@SuppressWarnings("rawtypes")
public void processVariableMap(RemoteDevice device, Map<String, StateVariableValue> values) {

    if (device != null && values != null) {

        SonosZonePlayer associatedPlayer = sonosZonePlayerCache.getByDevice(device);

        if (associatedPlayer == null) {
            logger.debug("There is no Sonos Player defined matching the device {}", device);
            return;
        }

        for (String stateVariable : values.keySet()) {

            // find all the CommandTypes that are defined for each
            // StateVariable
            List<SonosCommandType> supportedCommands = SonosCommandType.getCommandByVariable(stateVariable);

            StateVariableValue status = values.get(stateVariable);

            for (SonosCommandType sonosCommandType : supportedCommands) {

                // create a new State based on the type of Sonos Command and
                // the status value in the map
                Type newState = null;
                try {
                    newState = createStateForType((Class<? extends State>) sonosCommandType.getTypeClass(),
                            status.getValue().toString());
                } catch (BindingConfigParseException e) {
                    logger.error("Error parsing a value {} to a state variable of type {}", status.toString(),
                            sonosCommandType.getTypeClass().toString());
                }

                for (SonosBindingProvider provider : providers) {
                    List<String> qualifiedItems = provider.getItemNames(
                            sonosZonePlayerCache.getByDevice(device).getId(), sonosCommandType.getSonosCommand());
                    List<String> qualifiedItemsByUDN = provider.getItemNames(
                            sonosZonePlayerCache.getByDevice(device).getUdn().getIdentifierString(),
                            sonosCommandType.getSonosCommand());

                    for (String item : qualifiedItemsByUDN) {
                        if (!qualifiedItems.contains(item)) {
                            qualifiedItems.add(item);
                        }
                    }

                    for (String anItem : qualifiedItems) {
                        // get the openHAB commands attached to each Item at
                        // this given Provider
                        List<Command> commands = provider.getCommands(anItem, sonosCommandType.getSonosCommand());

                        if (provider.getAcceptedDataTypes(anItem).contains(sonosCommandType.getTypeClass())) {
                            if (newState != null) {
                                eventPublisher.postUpdate(anItem, (State) newState);
                            } else {
                                throw new IllegalClassException("Cannot process update for the command of type "
                                        + sonosCommandType.toString());
                            }
                        } else {
                            logger.warn("Cannot cast {} to an accepted state type for item {}",
                                    sonosCommandType.getTypeClass().toString(), anItem);
                        }
                    }
                }
            }
        }
    }
}
 

@Override
public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {
	deviceRemoved(new UpnpDevice(device));
}
 

@Override
public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {}
 

@Override
public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {}