import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
private void browse(DeviceDisplay device, String id) {

        mBrowsingDevices = id == null;

        updateTitleAndDescription();

        if (mBrowsingDevices) {
            mParentIdMap.clear();
            mListView.setAdapter(mListAdapter);
        } else {
            Service foundService = null;
            for (Service s : device.getDevice().getServices())
                for (Action a : s.getActions())
                    if ("browse".equalsIgnoreCase(a.getName())) {
                        foundService = s;
                        break;
                    }

            if (foundService != null) {
                mUpnpService.getControlPoint().execute(
                        new BrowseCallback(foundService, id, BrowseFlag.DIRECT_CHILDREN));
            }
        }
    }
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public Action appendAction(Map<Action, ActionExecutor> actions) throws LocalServiceBindingException {

        String name;
        if (getAnnotation().name().length() != 0) {
            name = getAnnotation().name();
        } else {
            name = AnnotationLocalServiceBinder.toUpnpActionName(getMethod().getName());
        }

        log.fine("Creating action and executor: " + name);

        List<ActionArgument> inputArguments = createInputArguments();
        Map<ActionArgument<LocalService>, StateVariableAccessor> outputArguments = createOutputArguments();

        inputArguments.addAll(outputArguments.keySet());
        ActionArgument<LocalService>[] actionArguments =
                inputArguments.toArray(new ActionArgument[inputArguments.size()]);

        Action action = new Action(name, actionArguments);
        ActionExecutor executor = createExecutor(outputArguments);

        actions.put(action, executor);
        return action;
    }
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
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");
    }
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
protected Map<Action, ActionExecutor> readActions(Class<?> clazz,
                                                  Map<StateVariable, StateVariableAccessor> stateVariables,
                                                  Set<Class> stringConvertibleTypes)
        throws LocalServiceBindingException {

    Map<Action, ActionExecutor> map = new HashMap();

    for (Method method : Reflections.getMethods(clazz, UpnpAction.class)) {
        AnnotationActionBinder actionBinder =
                new AnnotationActionBinder(method, stateVariables, stringConvertibleTypes);
        Action action = actionBinder.appendAction(map);
        if(isActionExcluded(action)) {
        	map.remove(action);
        }
    }

    return map;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
/**
 * Reads the output arguments after an action execution using accessors.
 *
 * @param action The action of which the output arguments are read.
 * @param instance The instance on which the accessors will be invoked.
 * @return <code>null</code> if the action has no output arguments, a single instance if it has one, an
 *         <code>Object[]</code> otherwise.
 * @throws Exception
 */
protected Object readOutputArgumentValues(Action<LocalService> action, Object instance) throws Exception {
    Object[] results = new Object[action.getOutputArguments().length];
    log.fine("Attempting to retrieve output argument values using accessor: " + results.length);

    int i = 0;
    for (ActionArgument outputArgument : action.getOutputArguments()) {
        log.finer("Calling acccessor method for: " + outputArgument);

        StateVariableAccessor accessor = getOutputArgumentAccessors().get(outputArgument);
        if (accessor != null) {
            log.fine("Calling accessor to read output argument value: " + accessor);
            results[i++] = accessor.read(instance);
        } else {
            throw new IllegalStateException("No accessor bound for: " + outputArgument);
        }
    }

    if (results.length == 1) {
        return results[0];
    }
    return results.length > 0 ? results : null;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public void testRendererGetProtocolInfo(){
		
	waitForService();
	LocalDevice rendererDevice = getService().getUpnpClient().getRegistry().getLocalDevice(new UDN(YaaccUpnpServerService.MEDIA_RENDERER_UDN_ID),false);
	LocalService connectionService = rendererDevice.findService(new ServiceId(UDAServiceId.DEFAULT_NAMESPACE,"ConnectionManager"));
	Action action = connectionService.getAction("GetProtocolInfo");
	ActionInvocation<LocalService> actionInvocation = new ActionInvocation<LocalService>(action);
	connectionService.getExecutor(action).execute(actionInvocation);
	if(actionInvocation.getFailure() != null){
		throw new RuntimeException(actionInvocation.getFailure().fillInStackTrace());
	}		
	
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public void testServerGetProtocolInfo(){
	
	waitForService();
	LocalDevice serverDevice = getService().getUpnpClient().getRegistry().getLocalDevice(new UDN(YaaccUpnpServerService.MEDIA_SERVER_UDN_ID),false);
	LocalService connectionService = serverDevice.findService(new ServiceId(UDAServiceId.DEFAULT_NAMESPACE,"ConnectionManager"));
	Action action = connectionService.getAction("GetProtocolInfo");
	ActionInvocation<LocalService> actionInvocation = new ActionInvocation<LocalService>(action);
	connectionService.getExecutor(action).execute(actionInvocation);
	if(actionInvocation.getFailure() != null){
		throw new RuntimeException(actionInvocation.getFailure().fillInStackTrace());
	}		
	
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
private void getConnectionInfos(UpnpClient upnpClient,
		final List<Device<?, ?, ?>> devices) throws Exception {
	for (Device<?, ?, ?> device : devices) {
		Service service = device.findService(new UDAServiceId(
				"ConnectionManager"));
		if (service != null) {
			Action getCurrentConnectionIds = service
					.getAction("GetCurrentConnectionIDs");
			assertNotNull(getCurrentConnectionIds);
			ActionInvocation getCurrentConnectionIdsInvocation = new ActionInvocation(
					getCurrentConnectionIds);
			ActionCallback getCurrentConnectionCallback = new ActionCallback(
					getCurrentConnectionIdsInvocation) {
				
				@Override
				public void success(ActionInvocation invocation) {
					ActionArgumentValue[] connectionIds = invocation
							.getOutput();
				    for (ActionArgumentValue connectionId : connectionIds) {
				    	Log.d(getClass().getName(), connectionId.getValue().toString());
						
					}
				}

				@Override
				public void failure(ActionInvocation actioninvocation,
						UpnpResponse upnpresponse, String s) {
					Log.d(getClass().getName(),"Failure:" + upnpresponse);

				}
			};

			upnpClient.getUpnpService().getControlPoint()
					.execute(getCurrentConnectionCallback);

		}
	}
	myWait();
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public Action[] createActions() {
    Action[] array = new Action[actions.size()];
    int i = 0;
    for (MutableAction action : actions) {
        array[i++] = action.build();
    }
    return array;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
private void generateActionList(Service serviceModel, Document descriptor, Element scpdElement) {

        Element actionListElement = appendNewElement(descriptor, scpdElement, ELEMENT.actionList);

        for (Action action : serviceModel.getActions()) {
            if (!action.getName().equals(QueryStateVariableAction.ACTION_NAME))
                generateAction(action, descriptor, actionListElement);
        }
    }
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
private void generateAction(Action action, Document descriptor, Element actionListElement) {

        Element actionElement = appendNewElement(descriptor, actionListElement, ELEMENT.action);

        appendNewElementIfNotNull(descriptor, actionElement, ELEMENT.name, action.getName());

        if (action.hasArguments()) {
            Element argumentListElement = appendNewElement(descriptor, actionElement, ELEMENT.argumentList);
            for (ActionArgument actionArgument : action.getArguments()) {
                generateActionArgument(actionArgument, descriptor, argumentListElement);
            }
        }
    }
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public OutgoingActionResponseMessage(UpnpResponse.Status status, Action action) {
    super(new UpnpResponse(status));

    if (action != null) {
        if (action instanceof QueryStateVariableAction) {
            this.actionNamespace = Constants.NS_UPNP_CONTROL_10;
        } else {
            this.actionNamespace = action.getService().getServiceType().toString();
        }
    }

    addHeaders();
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public RemoteActionInvocation(Action action,
                              ActionArgumentValue[] input,
                              ActionArgumentValue[] output,
                              RemoteClientInfo remoteClientInfo) {
    super(action, input, output, null);
    this.remoteClientInfo = remoteClientInfo;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public ActionInvocation(Action<S> action,
                        ActionArgumentValue<S>[] input,
                        ActionArgumentValue<S>[] output,
                        ClientInfo clientInfo) {
    if (action == null) {
        throw new IllegalArgumentException("Action can not be null");
    }
    this.action = action;

    setInput(input);
    setOutput(output);

    this.clientInfo = clientInfo;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
private static ActionInvocation buildActionInvocation(Service service) {
     // not really a A_ARG_TYPE_Result type but close enough
    ActionArgument argument = new ActionArgument("FeatureList", "A_ARG_TYPE_Result", ActionArgument.Direction.OUT);
    Action action = new Action("X_GetFeatureList", new ActionArgument[]{argument});
    try {
        // package method must be reflected
        Method m = Action.class.getDeclaredMethod("setService", Service.class);
        m.setAccessible(true);
        m.invoke(action, service);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new ActionInvocation(action);
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
@Override
public void printService()
{
	Service[] services = device.findServices();
	for (Service service : services)
	{
		Log.i(TAG, "\t Service : " + service);
		for (Action a : service.getActions())
		{
			Log.i(TAG, "\t\t Action : " + a);
		}
	}
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
@Override
public Service newInstance(ServiceType servicetype, ServiceId serviceid, URI uri, URI uri1, URI uri2, Action[] aaction,
                           StateVariable[] astatevariable) throws ValidationException {
    // TODO Auto-generated method stub
    return null;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public Action build() {
    return new Action(name, createActionArgumennts());
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
/**
 * Override this method to exclude action/methods after they have been discovered.
 */
protected  boolean isActionExcluded(Action action) {
	return false;
}
 

import org.fourthline.cling.model.meta.Action; //导入依赖的package包/类
public OutgoingActionRequestMessage(Action action, UpnpRequest operation) {
    super(operation);

    getHeaders().add(
            UpnpHeader.Type.CONTENT_TYPE,
            new ContentTypeHeader(ContentTypeHeader.DEFAULT_CONTENT_TYPE_UTF8)
    );

    SoapActionHeader soapActionHeader;
    if (action instanceof QueryStateVariableAction) {
        log.fine("Adding magic control SOAP action header for state variable query action");
        soapActionHeader = new SoapActionHeader(
                new SoapActionType(
                        SoapActionType.MAGIC_CONTROL_NS, SoapActionType.MAGIC_CONTROL_TYPE, null, action.getName()
                )
        );
    } else {
        soapActionHeader = new SoapActionHeader(
                new SoapActionType(
                        action.getService().getServiceType(),
                        action.getName()
                )
        );
    }

    // We need to keep it for later, convenience for writing the SOAP body XML
    actionNamespace = soapActionHeader.getValue().getTypeString();

    if (getOperation().getMethod().equals(UpnpRequest.Method.POST)) {

        getHeaders().add(UpnpHeader.Type.SOAPACTION, soapActionHeader);
        log.fine("Added SOAP action header: " + soapActionHeader);

    /* TODO: Finish the M-POST crap (or not)
    } else if (getOperation().getMethod().equals(UpnpRequest.Method.MPOST)) {

        getHeaders().add(UpnpHeader.Type.MAN, new MANHeader(Constants.SOAP_NS_ENVELOPE, "01"));

        getHeaders().add(UpnpHeader.Type.SOAPACTION, soapActionHeader);
        getHeaders().setPrefix(UpnpHeader.Type.SOAPACTION, "01");
        log.fine("Added SOAP action header with prefix '01': " + getHeaders().getFirstHeader(UpnpHeader.Type.SOAPACTION).getString());
        */

    } else {
        throw new IllegalArgumentException("Can't send action with request method: " + getOperation().getMethod());
    }
}