Update

examples/android/binder/java/io/grpc/binder/cpp/exampleclient/native.cc

@@ -0,0 +1,53 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <android/log.h>
+#include <jni.h>
+
+#include "examples/protos/helloworld.grpc.pb.h"
+#include "examples/protos/helloworld.pb.h"
+
+#include "src/core/ext/transport/binder/client/channel_create.h"
+#include "src/core/ext/transport/binder/security_policy/untrusted_security_policy.h"
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_io_grpc_binder_cpp_exampleclient_ButtonPressHandler_native_1entry(
+    JNIEnv* env, jobject /*this*/, jobject application) {
+  static bool first = true;
+  __android_log_print(ANDROID_LOG_INFO, "DemoClient", "Line number %d",
+                      __LINE__);
+  if (first) {
+    first = false;
+    grpc::experimental::BindToOnDeviceServerService(
+        env, application, "io.grpc.binder.cpp.exampleserver",
+        "io.grpc.binder.cpp.exampleserver.ExportedEndpointService");
+    return env->NewStringUTF("Clicked 1 time");
+  } else {
+    // TODO(mingcl): Use same signature security after it become available
+    auto channel = grpc::experimental::CreateBinderChannel(
+        env, application, "", "",
+        std::make_shared<
+            grpc::experimental::binder::UntrustedSecurityPolicy>());
+    auto stub = helloworld::Greeter::NewStub(channel);
+    grpc::ClientContext context;
+    helloworld::HelloRequest request;
+    helloworld::HelloReply response;
+    request.set_name("BinderTransportClient");
+    grpc::Status status = stub->SayHello(&context, request, &response);
+    if (status.ok()) {
+      return env->NewStringUTF(response.message().c_str());
+    }
+    return env->NewStringUTF("Clicked more than 1 time. Status not ok");
+  }
+}

examples/android/binder/java/io/grpc/binder/cpp/exampleserver/native.cc

@@ -0,0 +1,72 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <android/binder_auto_utils.h>
+#include <android/binder_ibinder.h>
+#include <android/binder_ibinder_jni.h>
+#include <android/binder_interface_utils.h>
+#include <android/log.h>
+#include <jni.h>
+
+#include "examples/protos/helloworld.grpc.pb.h"
+#include "examples/protos/helloworld.pb.h"
+
+#include <grpcpp/grpcpp.h>
+
+#include "src/core/ext/transport/binder/security_policy/untrusted_security_policy.h"
+#include "src/core/ext/transport/binder/server/binder_server.h"
+#include "src/core/ext/transport/binder/server/binder_server_credentials.h"
+
+namespace {
+class GreeterService : public helloworld::Greeter::Service {
+ public:
+  grpc::Status SayHello(grpc::ServerContext*,
+                        const helloworld::HelloRequest* request,
+                        helloworld::HelloReply* response) override {
+    __android_log_print(ANDROID_LOG_INFO, "DemoServer", "Line number %d",
+                        __LINE__);
+    __android_log_print(ANDROID_LOG_INFO, "DemoServer", "Got hello request: %s",
+                        request->name().c_str());
+    response->set_message("Hi, " + request->name());
+    return grpc::Status::OK;
+  }
+};
+
+}  // namespace
+
+extern "C" JNIEXPORT void JNICALL
+Java_io_grpc_binder_cpp_exampleserver_ExportedEndpointService_init_1grpc_1server(
+    JNIEnv* env, jobject /*this*/) {
+  __android_log_print(ANDROID_LOG_INFO, "DemoServer", "Line number %d",
+                      __LINE__);
+  static std::unique_ptr<grpc::Server> server = nullptr;
+
+  if (server != nullptr) {
+    // Already initiated
+    return;
+  }
+
+  static GreeterService service;
+  grpc::ServerBuilder server_builder;
+  server_builder.RegisterService(&service);
+
+  // TODO(mingcl): Use same signature security after it become available
+  server_builder.AddListeningPort(
+      "binder:example.service",
+      grpc::experimental::BinderServerCredentials(
+          std::make_shared<
+              grpc::experimental::binder::UntrustedSecurityPolicy>()));
+
+  server = server_builder.BuildAndStart();
+}

examples/android/helloworld/app/src/main/cpp/grpc-helloworld.cc

@@ -0,0 +1,142 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <atomic>
+
+#include <grpc++/grpc++.h>
+#include <jni.h>
+
+#include "helloworld.grpc.pb.h"
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::Status;
+using helloworld::Greeter;
+using helloworld::HelloReply;
+using helloworld::HelloRequest;
+
+std::atomic<bool> stop_server(false);
+
+// Logic and data behind the server's behavior.
+class GreeterServiceImpl final : public Greeter::Service {
+  Status SayHello(ServerContext* context, const HelloRequest* request,
+                  HelloReply* reply) override {
+    std::string prefix("Hello ");
+    reply->set_message(prefix + request->name());
+    return Status::OK;
+  }
+};
+
+void StartServer(JNIEnv* env, jobject obj, jmethodID is_cancelled_mid,
+                 int port) {
+  const int host_port_buf_size = 1024;
+  char host_port[host_port_buf_size];
+  snprintf(host_port, host_port_buf_size, "0.0.0.0:%d", port);
+
+  GreeterServiceImpl service;
+  ServerBuilder builder;
+  // Listen on the given address without any authentication mechanism.
+  builder.AddListeningPort(host_port, grpc::InsecureServerCredentials());
+  // Register "service" as the instance through which we'll communicate with
+  // clients. In this case it corresponds to an *synchronous* service.
+  builder.RegisterService(&service);
+  // Finally assemble the server.
+  std::unique_ptr<Server> server(builder.BuildAndStart());
+  while (!stop_server.load()) {
+    // Check with the Java code to see if the user has requested the server stop or the app is no
+    // longer in the foreground.
+    jboolean is_cancelled = env->CallBooleanMethod(obj, is_cancelled_mid);
+    if (is_cancelled == JNI_TRUE) {
+      stop_server = true;
+    }
+  }
+}
+
+class GreeterClient {
+ public:
+  GreeterClient(std::shared_ptr<Channel> channel)
+      : stub_(Greeter::NewStub(channel)) {}
+
+  // Assembles the client's payload, sends it and presents the response back
+  // from the server.
+  std::string SayHello(const std::string& user) {
+    // Data we are sending to the server.
+    HelloRequest request;
+    request.set_name(user);
+
+    // Container for the data we expect from the server.
+    HelloReply reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+    // The actual RPC.
+    Status status = stub_->SayHello(&context, request, &reply);
+
+    if (status.ok()) {
+      return reply.message();
+    } else {
+      return status.error_message();
+    }
+  }
+
+ private:
+  std::unique_ptr<Greeter::Stub> stub_;
+};
+
+// Send an RPC and return the response. Invoked from Java code.
+extern "C" JNIEXPORT jstring JNICALL
+Java_io_grpc_helloworldexample_cpp_HelloworldActivity_sayHello(
+    JNIEnv* env, jobject obj_unused, jstring host_raw, jint port_raw,
+    jstring message_raw) {
+  const char* host_chars = env->GetStringUTFChars(host_raw, (jboolean*)0);
+  std::string host(host_chars, env->GetStringUTFLength(host_raw));
+
+  int port = static_cast<int>(port_raw);
+
+  const char* message_chars = env->GetStringUTFChars(message_raw, (jboolean*)0);
+  std::string message(message_chars, env->GetStringUTFLength(message_raw));
+
+  const int host_port_buf_size = 1024;
+  char host_port[host_port_buf_size];
+  snprintf(host_port, host_port_buf_size, "%s:%d", host.c_str(), port);
+
+  GreeterClient greeter(
+      grpc::CreateChannel(host_port, grpc::InsecureChannelCredentials()));
+  std::string reply = greeter.SayHello(message);
+
+  return env->NewStringUTF(reply.c_str());
+}
+
+// Start the server. Invoked from Java code.
+extern "C" JNIEXPORT void JNICALL
+Java_io_grpc_helloworldexample_cpp_HelloworldActivity_startServer(
+    JNIEnv* env, jobject obj_this, jint port_raw) {
+  int port = static_cast<int>(port_raw);
+
+  jclass cls = env->GetObjectClass(obj_this);
+  jmethodID is_cancelled_mid =
+      env->GetMethodID(cls, "isRunServerTaskCancelled", "()Z");
+
+  stop_server = false;
+
+  StartServer(env, obj_this, is_cancelled_mid, port);
+}

examples/cpp/compression/greeter_client.cc

@@ -0,0 +1,93 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#ifdef BAZEL_BUILD
+#include "examples/protos/helloworld.grpc.pb.h"
+#else
+#include "helloworld.grpc.pb.h"
+#endif
+
+using grpc::Channel;
+using grpc::ChannelArguments;
+using grpc::ClientContext;
+using grpc::Status;
+using helloworld::Greeter;
+using helloworld::HelloReply;
+using helloworld::HelloRequest;
+
+class GreeterClient {
+ public:
+  GreeterClient(std::shared_ptr<Channel> channel)
+      : stub_(Greeter::NewStub(channel)) {}
+
+  // Assembles the client's payload, sends it and presents the response back
+  // from the server.
+  std::string SayHello(const std::string& user) {
+    // Data we are sending to the server.
+    HelloRequest request;
+    request.set_name(user);
+
+    // Container for the data we expect from the server.
+    HelloReply reply;
+
+    // Context for the client. It could be used to convey extra information to
+    // the server and/or tweak certain RPC behaviors.
+    ClientContext context;
+
+    // Overwrite the call's compression algorithm to DEFLATE.
+    context.set_compression_algorithm(GRPC_COMPRESS_DEFLATE);
+
+    // The actual RPC.
+    Status status = stub_->SayHello(&context, request, &reply);
+
+    // Act upon its status.
+    if (status.ok()) {
+      return reply.message();
+    } else {
+      std::cout << status.error_code() << ": " << status.error_message()
+                << std::endl;
+      return "RPC failed";
+    }
+  }
+
+ private:
+  std::unique_ptr<Greeter::Stub> stub_;
+};
+
+int main(int argc, char** argv) {
+  // Instantiate the client. It requires a channel, out of which the actual RPCs
+  // are created. This channel models a connection to an endpoint (in this case,
+  // localhost at port 50051). We indicate that the channel isn't authenticated
+  // (use of InsecureChannelCredentials()).
+  ChannelArguments args;
+  // Set the default compression algorithm for the channel.
+  args.SetCompressionAlgorithm(GRPC_COMPRESS_GZIP);
+  GreeterClient greeter(grpc::CreateCustomChannel(
+      "localhost:50051", grpc::InsecureChannelCredentials(), args));
+  std::string user("world world world world");
+  std::string reply = greeter.SayHello(user);
+  std::cout << "Greeter received: " << reply << std::endl;
+
+  return 0;
+}