The following is a list of the properties that an AU request might have.

zkau.sendasap and zkau.send are two of most common methods to send an AU request to the server.

zkau.send({uuid: cmp.id, cmd: "onChange", data: [cmp.value]},
zkau.asapTimeout(cmp, "onChange"));

zkau.send(evt, zkau.asapTimeout(evt.uuid, evt.cmd, timeout));

There are two callbacks you can register to do something before sending AU requests, and after receiving the responses.

zkau.addOnSend(function() {
//check any change and call zkau.sendAhead to carry the change back
});

Here is a list of methods to simply the sending of particular AU requests, such as onClose. They are all based on zkau.send.

There are two kinds of commands: global commands and component-specific commands. The global commands are available to all kind of components, while component-specific commands are available only to a particular kind of components. More precisely, global commands are maintained in a global map, while component-specific commands is maintained in an individual component.

If none of built-in command fulfills your requirement, you can develop your own command.

public class SuperButton extends AbstractComponent {
    private static Command _flycmd = new ComponentCommand("onFly", 0) {    
        protected void process(AuRequest request) {        
            final SuperButton btn = (SuperButton)request.getComponent();            
            btn.doFly();            
                    Events.postEvent(new Event(getId(), btn, request.getData()));}                    
    }; //note: it won't register itself to the global map    
        //because it is extended from ComponentCommand)        
    public Command getCommand(String cmdId) {    
        return "fly".equals(cmdId) ? _flycmd: null;        
    }    
    void doFly() {    
        //whatever        
    }    
}

class FlyCommand extends Command {
public FlyCommand(String id, int flags) {
super(id, flags);
}
protected process(AuRequest request) {
final SuperButton btn = (SuperButton)request.getComponent();
        btn.doFly();        
Events.postEvent(new Event(getId(), btn, request.getData()));
}
}

public class SuperButton extends AbstractComponent {
    static {    
            new FlyCommand("onFly", 0); //register itself automatically}            
...

public Object getExtraCtrl();

public interface Flyable {
public void doFly();
}

public class SuperButton extends AbstractComponent {
    public Object newExtraCtrl() {    
        return new ExtraCtrl();        
    }    
    private void doFly() { //make it inaccessible    
        //whatever        
    }    
    private class ExtraCtrl implements Flyable {    
public void doFly() {
SuperButto.this.doFly();
}
}
...

class FlyCommand extends Command {
public FlyCommand(String id, int flags) {
super(id, flags);
}
protected process(AuRequest request) {
final Component comp = request.getComponent();
        if (comp instanceof Flyable)        
((Flyable)comp).doFly();
Events.postEvent(new Event(getId(), comp, request.getData()));
}
}

When implementing a sophisticated component, you might want to pass multiple values (i.e., an array of values) to an attribute. At the server side, you invoke the smartUpdateValues method. At the client, the setAttr callback will be called with additional arguments. For example, at the server, you invoke

smartUpdateValues("fly", new String[] {"low", "fast"});

Then, at the client, you can handle it as follows.

zkSuperButton.setAttr = function (cmp, name, value1, value2) {
if ("fly" == name) {
fly(value1, value2);
...

JavaScript Tip: You can use arguments.length to determine how many arguments are passed.

The invoke response is used to invoke a callback. For example, you can send an AU response at the server as follows.

    public void fly() {response("ctrl", new AuInvoke(this, "fly", "low", "fast"));}    

Then, at the client, the following callback will be called.

    zkSuperButton.fly = function (cmp, height, speed) {//whatever    
}

Tip: As shown above, we can use a AU response and a smart update to do the similar task (fly in this example). But, there is a difference: the AU response is sent even if the component is invalidated, while the smart update won't.

Thus, if the init callback will handle everything, the smart update shall be used (otherwise, you will do it twice when it is invalidated).

The script response is used to execute any JavaScript codes at the client, not just the callbacks. For example,

public void fly() {
    response("ctrl",    
new AuScript(this, "zkSuperButton.fly('" + getUuid() + "','low','fast')"));
}

Since the JavaScript codes are hardcoded, it is sometimes not easy to support multiple molds. For example, assume you want to use the same Java class to implement another mold. Then, the JavaScript codes that implements fly might be different. So, you might have to do as follows.

public void fly() {
    response("ctrl",    
new AuScript(this,
("SuperButton".equals(getMold()) ? "zkSuperButton": "zkGiantButton")
+ ".fly('" + getUuid() + "','low','fast')"));
}

On the other hand, if you use the invoke response, you can have the same response but define a different component type, say GiantButton. Then, you don't modify Java class. Rather, provide another callback:

zkGiantButton.fly = function (cmp, height, speed) {
    //whatever    
}

In general, the invoke response is recommended if applicable.

Unlike the AU request's commands, you rarely need to develop your own AU response since the invoke response can serve almost everything. However, if you prefer to provide your own response, you can follow the instructions described in this section.

First, you have to implement a Java class extending from the org.zkoss.zk.au.AuResponse class.

public AuFly extends AuResponse {
    public AuFly(SuperButton comp, String height, String speed) {    
super("fly", comp, new String[] {comp.getUuid(), height, speed});
}
}

where "fly" is the response name, and the third argument (String[]) of AuResponse's constructor will be passed to the client. The response name must be unique. The third argument is called the response data.

Then, at the client side, you shall provide a method called zkau.cmd1.fly to handle it.

zkau.cmd1.fly = function (uuid, cmp, height, speed) {
//whatever
}

There are two set of response handlers: zkau.cmd0 and zkau.cmd1. zkau.cmd0 is used to handle responses that are applied to the whole browser window, while zkau.cmd1 is for individual component.

If zkau.cmd1 is overridden, the first element of the response data must be the component UUID (comp.getUuid() in the above example). Then, ZK Client Engine will convert it to a reference to a component, and then invoke the response's handler with UUID and the reference as the first two arguments (refer to zkau.cmd.fly in the above example).