mojo: generate Proxies and Stubs for java bindings.

mojo/public/tools/bindings/generators/java_templates/interface_definition.tmpl

 {% from "constant_definition.tmpl" import constant_def %}
 {% from "enum_definition.tmpl" import enum_def %}
+{% from "struct_definition.tmpl" import struct_def %}
 
-{%- macro declare_params(parameters) %}
+{%- macro declare_params(parameters, boxed=false) %}
 {%-   for param in parameters -%}
-{{param.kind|java_type(False)}} {{param|name}}
+{{param.kind|java_type(boxed)}} {{param|name}}
 {%- if not loop.last %}, {% endif %}
 {%-   endfor %}
 {%- endmacro %}
 
 {% macro declare_request_params(method) %}
 {{declare_params(method.parameters)}}
 {%-   if method.response_parameters != None -%}
 {%- if method.parameters %}, {% endif %}
 {{method|interface_response_name}} callback
 {%-   endif -%}
 {% endmacro %}
 
 {%- macro declare_callback(method) -%}
+
 interface {{method|interface_response_name}} extends org.chromium.mojo.bindings.Callbacks.Callback{{method.response_parameters|length}}<
 {%-   for param in method.response_parameters -%}
 {{param.kind|java_type(True)}}
 {%- if not loop.last %}, {% endif %}
 {%-   endfor -%}
 > { }
 {%- endmacro -%}
 
-{%- macro super_class(client) -%}
+{%- macro run_callback(variable, parameters) -%}
+{%-   if parameters -%}
+{%-     for param in parameters -%}
+{{variable}}.{{param|name}}
+{%-   if not loop.last %}, {% endif %}
+{%-     endfor -%}
+{%-   endif -%}
+{%- endmacro -%}
+
+{%- macro super_class(client, with_generic=True) -%}
 {%-   if client -%}
-org.chromium.mojo.bindings.InterfaceWithClient<{{client|java_type}}>
+org.chromium.mojo.bindings.InterfaceWithClient{% if with_generic %}<{{client|java_type}}>{% endif %}
 {%-   else -%}
 org.chromium.mojo.bindings.Interface
 {%-   endif -%}
 {%- endmacro -%}
 
+{%- macro flags(method, is_parameter) -%}
+{%-  if not method.response_parameters -%}
+0
+{%-   elif is_parameter: -%}
+org.chromium.mojo.bindings.MessageHeader.MESSAGE_EXPECTS_RESPONSE_FLAG
+{%-   else -%}
+org.chromium.mojo.bindings.MessageHeader.MESSAGE_IS_RESPONSE_FLAG
+{%-   endif -%}
+{%- endmacro -%}
+
+{%- macro builder_class(interface, client, fqbc=False) -%}
+{% if fqbc %}{{super_class(client, False)}}.{% endif %}Builder<{{interface|name}}, {{interface|name}}.Proxy
+{%- if client -%}, {{client|java_type}}{%-  endif -%}
+>
+{%- endmacro -%}
+
+{%- macro builder_def(interface, client) -%}
+public static final {{builder_class(interface, client, True)}} BUILDER =
+        new {{builder_class(interface, client, True)}}() {
+
+    public Proxy buildProxy(org.chromium.mojo.system.Core core,
+                            org.chromium.mojo.bindings.MessageReceiverWithResponder messageReceiver) {
+        return new Proxy(core, messageReceiver);
+    }
+
+    public Stub buildStub(org.chromium.mojo.system.Core core, {{interface|name}} impl) {
+        return new Stub(core, impl);
+    }
+
+    public {{interface|name}}[] newArray(int size) {
+      return new {{interface|name}}[size];
+    }
+{%  if client %}
+
+    protected org.chromium.mojo.bindings.Interface.Builder<{{client|java_type}}, ?> getClientBuilder() {
+        return {{client|java_type}}.BUILDER;
+    }
+{%  endif %}
+};
+{%- endmacro -%}
+
+{%- macro accept_body(interface, with_response) -%}
+{% if (interface|has_method_with_response and with_response) or
+      (interface|has_method_without_response and not with_response) %}
+try {
+    org.chromium.mojo.bindings.MessageHeader header = message.getHeader();
+    switch(header.getType()) {
+{%   for method in interface.methods %}
+{%     if (with_response and method.response_parameters) or
+        (not with_response and not method.response_parameters) %}
+{%       set request_struct = method|struct_from_method %}
+{%       if with_response %}
+{%         set response_struct = method|response_struct_from_method %}
+{%       endif %}
+        case {{method|method_ordinal_name}}: {
+                if (!header.validateHeader({{flags(method, True)}})) {
+                    return false;
+                }
+{%       if method.parameters %}
+                {{request_struct|name}} data =
+                        {{request_struct|name}}.deserialize(message.getPayload());
+{%       else %}
+                {{request_struct|name}}.deserialize(message.getPayload());
+{%       endif %}
+                getImpl().{{method|name}}({{run_callback('data', method.parameters)}}{% if with_response %}{% if method.parameters %}, {% endif %}new {{response_struct|name}}ProxyToResponder(getCore(), receiver, header.getRequestId()){% endif %});
+                return true;
+            }
+{%     endif %}
+{%   endfor %}
+    }
+} catch (org.chromium.mojo.bindings.DeserializationException e) {
+}
+{% endif %}
+return false;
+{%- endmacro -%}
+
 {% macro interface_def(interface, client) %}
 public interface {{interface|name}} extends {{super_class(client)}} {
-
-    public static final Object BUILDER = new Object();
-
 {%  for constant in interface.constants %}
 
     {{constant_def(constant)|indent(4)}}
 {%  endfor %}
 {%  for enum in interface.enums %}
 
     {{enum_def(enum, false)|indent(4)}}
 {% endfor %}
+
+    public interface Proxy extends {{interface|name}}, {{super_class(client, False)}}.Proxy{% if client %}<{{client|java_type}}>{% endif %} {
+    }
+
+    {{builder_class(interface, client)}} BUILDER = {{interface|name}}Internal.BUILDER;
 {% for method in interface.methods %}
 
     void {{method|name}}({{declare_request_params(method)}});
 {%   if method.response_parameters %}
     {{declare_callback(method)|indent(4)}}
 {%   endif %}
 {% endfor %}
+}
+{% endmacro %}
+
+{% macro interface_internal_def(interface, client) %}
+class {{interface|name}}Internal {

[rmcilroy, 2014/08/21 14:43:52]

Are you sure this is safe to do?  What if there is a mojom type with the same
name?  Personally I think this should be a private inner class, would that be
possible?

[qsr, 2014/08/22 08:11:19]

 It would be possible, but the reason I put it there is because the interface
class would then be cluttered with a lot of code, which makes it harder to see
immediately the important part (the method to implement)

[rmcilroy, 2014/08/26 10:18:23]

That makes sense.  I could still see clients wanting to create an API with an
Baz and BazInternal mojo API though. How about putting it in a separate package
as well as a suffix to the class name (e.g., foo.bar.internal.BazImpl for the
foo.bar.Baz interface)?  That way it should be a bit safer?

[qsr, 2014/08/26 12:43:56]

 The issue with this is that all internal class are right now package protected
and they would have to be public if we move those in their own package. WDYT?

[rmcilroy, 2014/08/26 17:04:03]

In that case it's probably better to be in the same package, but could we have a
name which would never be chosen (or at lease less likely to be chosen) as a
mojo interface name - e.g., Baz_InternalImpl (where the '_' should never be in a
mojo name Interface name, right)? 

[qsr, 2014/08/27 07:32:26]

Changed to Baz_Internal. It is not possible to generate this name. If you name a
class with _, they will be just considered as word separator, but the generated
class will be uppercamelcase.

+
+    {{builder_def(interface, client)|indent(4)}}
+
+{% for method in interface.methods %}
+    private static final int {{method|method_ordinal_name}} = {{method.ordinal}};
+{% endfor %}
+
+    static final class Proxy extends {% if client %}org.chromium.mojo.bindings.InterfaceWithClient.AbstractProxy<{{client|java_type}}>{% else %}org.chromium.mojo.bindings.Interface.AbstractProxy{% endif %} implements {{interface|name}}.Proxy {
+
+        Proxy(org.chromium.mojo.system.Core core,
+              org.chromium.mojo.bindings.MessageReceiverWithResponder messageReceiver) {
+            super(core, messageReceiver);
+        }
+{% for method in interface.methods %}
+
+        @Override
+        public void {{method|name}}({{declare_request_params(method)}}) {
+{%   set request_struct = method|struct_from_method %}
+            {{request_struct|name}} message = new {{request_struct|name}}();
+{%   for param in method.parameters %}
+            message.{{param|name}} = {{param|name}};
+{%   endfor %}
+{%   if method.response_parameters %}
+            getMessageReceiver().acceptWithResponder(
+                    message.serializeWithHeader(
+                            getCore(),
+                            new org.chromium.mojo.bindings.MessageHeader(
+                                    {{method|method_ordinal_name}},
+                                    {{flags(method, True)}},
+                                    0)),
+                    new {{method|response_struct_from_method|name}}ForwardToCallback(callback));
+{%   else %}
+            getMessageReceiver().accept(
+                    message.serializeWithHeader(
+                            getCore(),
+                            new org.chromium.mojo.bindings.MessageHeader({{method|method_ordinal_name}})));
+{%   endif %}
+        }
+{% endfor %}
+
+    }
+
+    static final class Stub extends org.chromium.mojo.bindings.Interface.Stub<{{interface|name}}> {
+
+        Stub(org.chromium.mojo.system.Core core, {{interface|name}} impl) {
+            super(core, impl);
+        }
+
+        @Override
+        public boolean accept(org.chromium.mojo.bindings.MessageWithHeader message) {
+            {{accept_body(interface, False)|indent(12)}}
+        }
+
+        @Override
+        public boolean acceptWithResponder(org.chromium.mojo.bindings.MessageWithHeader message, org.chromium.mojo.bindings.MessageReceiver receiver) {
+            {{accept_body(interface, True)|indent(12)}}
+        }
+    }
+{% for method in interface.methods %}
+
+    {{ struct_def(method|struct_from_method, True)|indent(4) }}
+{%   if method.response_parameters %}
+{%   set response_struct = method|response_struct_from_method %}
+
+    {{ struct_def(response_struct, True)|indent(4) }}
+
+    static class {{response_struct|name}}ForwardToCallback extends org.chromium.mojo.bindings.SideEffectFreeCloseable
+            implements org.chromium.mojo.bindings.MessageReceiver {
+        private final {{interface|name}}.{{method|interface_response_name}} mCallback;
+
+        {{response_struct|name}}ForwardToCallback({{interface|name}}.{{method|interface_response_name}} callback) {
+            this.mCallback = callback;
+        }
+
+        @Override
+        public boolean accept(org.chromium.mojo.bindings.MessageWithHeader message) {
+            try {
+                org.chromium.mojo.bindings.MessageHeader header = message.getHeader();
+                if (!header.validateHeader({{method|method_ordinal_name}},
+                                           {{flags(method, False)}})) {
+                    return false;
+                }
+                {{response_struct|name}} response = {{response_struct|name}}.deserialize(message.getPayload());
+                mCallback.call({{run_callback('response', method.response_parameters)}});
+                return true;
+            } catch (org.chromium.mojo.bindings.DeserializationException e) {
+                return false;
+            }
+        }
+    }
+
+    static class {{response_struct|name}}ProxyToResponder implements {{interface|name}}.{{method|interface_response_name}} {
+
+        private final org.chromium.mojo.system.Core mCore;
+        private final org.chromium.mojo.bindings.MessageReceiver mMessageReceiver;
+        private final long mRequestId;
+
+        {{response_struct|name}}ProxyToResponder(
+                org.chromium.mojo.system.Core core,
+                org.chromium.mojo.bindings.MessageReceiver messageReceiver,
+                long requestId) {
+            mCore = core;
+            mMessageReceiver = messageReceiver;
+            mRequestId = requestId;
+        }
+
+        @Override
+        public void call({{declare_params(method.response_parameters, true)}}) {
+            {{response_struct|name}} response = new {{response_struct|name}}();
+{%   for param in method.response_parameters %}
+            response.{{param|name}} = {{param|name}};
+{%   endfor %}
+            org.chromium.mojo.bindings.MessageWithHeader message =
+                    response.serializeWithHeader(
+                            mCore,
+                            new org.chromium.mojo.bindings.MessageHeader(
+                                    {{method|method_ordinal_name}},
+                                    {{flags(method, False)}},
+                                    mRequestId));
+            mMessageReceiver.accept(message);
+        }
+    }
+{%   endif %}
+{% endfor %}
 
 }
 {% endmacro %}