generate_java_proxy.cpp

// Copyright (c) 2026 Samsung Electronics Co., Ltd. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

#include "cc_service.h"
#include "generate_java_proxy.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <android-base/stringprintf.h>

#include "aidl_to_common.h"
#include "aidl_to_java.h"
#include "code_writer.h"
#include "logging.h"
#include "os.h"

using android::base::StringPrintf;

namespace android {
namespace aidl {
namespace java {

static string TAG = "GenerateProxyService";
static string INTERNAL_PACKAGE = "com.islet.binder.service";

static string GetProxyServiceFilePath(const string path, const Options& options, const string class_name) {
  string result = path;

  // add the filename
  result += class_name;
  if (options.TargetLanguage() == Options::Language::JAVA) {
    result += ".java";
  } else if (options.IsCppOutput()) {
    result += ".cpp";
  } else if (options.TargetLanguage() == Options::Language::RUST) {
    result += ".rs";
  } else {
    AIDL_FATAL("Unknown target language");
    return "";
  }
  AIDL_WARN(TAG)
      << "GetProxyServiceFilePath result: " << result;

  return result;
}

void GenerateImports(CodeWriter& out, const AidlDefinedType& defined_type) {
  const AidlInterface* iface = defined_type.AsInterface();
  const string pkg = defined_type.GetPackage();
  out << R"(
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import java.lang.IllegalStateException;

import com.islet.binder.service.Reader;
import com.islet.binder.service.Logger;
import com.islet.binder.service.VmManager;
import com.islet.binder.service.IRealmService;
)";

  out << "import "+ pkg + "." + iface->GetName() + ";\n\n";
}


static shared_ptr<ClassElement> GenerateMemberVariables(const string class_name, const string iface_name) {
  string member_variables = "private static final String TAG = \"" + class_name + "\";";
  member_variables += R"(
private Logger mLogger;
private VmManager mVmManager;
)";
  member_variables += "private " + iface_name + " mTargetService = null;\n";

  return std::make_shared<LiteralClassElement>(member_variables);
}

static shared_ptr<ClassElement> GenerateOnCreateMethod() {
  string method = R"(
@Override
public void onCreate() {
    mLogger = new Logger(this, TAG, "service2.txt");
    mVmManager = new VmManager(getApplication(), mLogger);
    mLogger.write("Entering onCreate();");

    // Set VM service callback to receive notifications
    mVmManager.setVmServiceCallback(this);

    mVmManager.vmRun();
    // we cannot call mVmManager.getVMService().onCreate() here as the service is not connected yet

    mLogger.write("Returning onCreate();");
}
)";
  return std::make_shared<LiteralClassElement>(method);
}

static shared_ptr<ClassElement> GenerateOnBindMethod() {
  string method = R"(
@Override
public IBinder onBind(Intent intent) {
    mLogger.write("Entering onBind();");

    // we cannot call mVmManager.getVMService().onBind() here as the service is not connected yet

    mLogger.write("Returning onBind();");
    return mBinder;
}
)";
  return std::make_shared<LiteralClassElement>(method);
}

static shared_ptr<ClassElement> GenerateOnUnBindMethod() {
  string method = R"(
@Override
public boolean onUnbind(Intent intent) {
    mLogger.write("Entering onUnbind();");
    mLogger.write("Returning onUnbind();");
    return false; // return true if you want onRebind() to be called later
}
)";
  return std::make_shared<LiteralClassElement>(method);
}

static shared_ptr<ClassElement> GenerateOnDestroyMethod() {
  string method = R"(
@Override
public void onDestroy() {
    mLogger.write("Entering onDestroy();");

    mVmManager.vmStop();

    mLogger.write("Returning onDestroy();");
}
)";
  return std::make_shared<LiteralClassElement>(method);
}

static shared_ptr<ClassElement> GenerateVmServiceCallbackMethods(const string iface_name) {
  string methods = R"(
  // VmServiceCallback implementation
  @Override
  public void onVmServiceReady(IRealmService vmService) {
    mLogger.write("onVmServiceReady is called, please wait for binding the target service..");

    // You can perform additional initialization work here when VM service is ready.
    // For example: call specific VM service methods, set up states, etc.
    try {
      // Call onBindForTargetService to get the target service binder
      IBinder targetBinder = vmService.onBindForTargetService();
      if (targetBinder != null) {
      )";
  methods += "          mTargetService = " + iface_name + ".Stub.asInterface(targetBinder);\n";
  methods += R"(
        mLogger.write("Target service binder successfully obtained and converted.");
      } else {
        mLogger.write("Failed to obtain target service binder - binder is null.");
      }
    } catch (Exception e) {
      mLogger.write("Error in onVmServiceReady: " + e.getMessage());
    }
  }

  @Override
  public void onVmServiceError(String errorMessage) {
    mLogger.write("VM service error occurred: " + errorMessage);

    // You can implement error handling logic here when VM service connection fails.
    // For example: retry logic, notify user, fallback behavior, etc.
    mLogger.write("Handling VM service connection error...");
  }
)";
  return std::make_shared<LiteralClassElement>(methods);
}

static string GetJavaFormatSpecifier(const std::unique_ptr<AidlArgument>& arg) {
  string type = arg->GetType().GetName();
  if (type == "int" || type == "long" || type == "short") return "%d";
  if (type == "float" || type == "double") return "%f";
  if (type == "String") return "%s";
  return "%s";  // fallback
}

static string GenerateProxyCallback(const AidlInterface* cb_iface, const string& cb_arg_name, const string& type) {
  string ret = "";
  CodeWriterPtr writer = CodeWriter::ForString(&ret);
  CodeWriter& code = *writer;
  code << type + " proxy_" + cb_arg_name + " = new " + type + ".Stub() {\n";
  code.Indent();
  for (const auto& m : cb_iface->GetMethods()) {
    string m_arguments = "";
    code << "@Override\n";
    code << "public void " + m->GetName() + "(";

    const auto& args = m->GetArguments();
    for (size_t i = 0; i < args.size(); ++i) {
      const auto& arg = args[i];
      m_arguments += arg->GetName();
      code << JavaSignatureOf(arg->GetType()) + " " + arg->GetName();
      if (i != args.size() - 1) {
        code << ", ";
        m_arguments += ", ";
      }
    }
    code << ") throws IllegalStateException, RemoteException {\n";

    code.Indent();
    code << "mLogger.write(\"" + m->GetName() + "() called from realm world\");\n";
    code << cb_arg_name + "." + m->GetName() + "(" + m_arguments + ");\n";
    code.Dedent();
    code << "}\n";
  }
  code.Dedent();
  code << "};\n";

  return ret;
}

struct ArgProcessingResult {
  string proxy_args_str;
  string log_args_str;
  string proxy_callback_code;
};

static shared_ptr<Method> CreateMethodSkeleton(const AidlMethod& method) {
  auto aidl_method = std::make_shared<Method>();
  aidl_method->modifiers = PUBLIC | OVERRIDE;
  aidl_method->returnType = JavaSignatureOf(method.GetType());
  aidl_method->name = method.GetName();
  aidl_method->statements = std::make_shared<StatementBlock>();
  aidl_method->exceptions.push_back("IllegalStateException, RemoteException");

  for (const auto& arg : method.GetArguments()) {
    aidl_method->parameters.push_back(
        std::make_shared<Variable>(JavaSignatureOf(arg->GetType()), arg->GetName()));
  }
  return aidl_method;
}

static ArgProcessingResult ProcessArguments(const std::vector<std::unique_ptr<AidlArgument>>& args) {
  ArgProcessingResult result;
  for (size_t i = 0; i < args.size(); ++i) {
    const auto& arg = args[i];
    string arg_name = arg->GetName();
    result.log_args_str += arg_name;

    const AidlDefinedType* def = arg->GetType().GetDefinedType();
    if (def) {
      const AidlInterface* cb_iface = def->AsInterface();
      if (cb_iface) {
        result.proxy_callback_code = GenerateProxyCallback(cb_iface, arg_name, JavaSignatureOf(arg->GetType()));
        arg_name.insert(0, "proxy_");
      }
    }
    result.proxy_args_str += arg_name;

    if (i != args.size() - 1) {
      result.proxy_args_str += ", ";
      result.log_args_str += ", ";
    }
  }
  return result;
}

static string GenerateMethodLoggingCode(const AidlMethod& method, const string& log_args_str) {
  string full_method_name = "mBinder." + method.GetName();
  string start_log_str = "mLogger.write(String.format(\"Entering %s(";

  const auto& args = method.GetArguments();
  for (size_t i = 0; i < args.size(); ++i) {
    start_log_str += GetJavaFormatSpecifier(args[i]);
    if (i != args.size() - 1) {
      start_log_str += ", ";
    }
  }

  if (args.empty()) {
    start_log_str += ")\", \"" + full_method_name + "\"));\n";
  } else {
    start_log_str += ")\", \"" + full_method_name + "\", " + log_args_str + "));\n";
  }
  return start_log_str;
}

static string GenerateVmServiceCallCode(const AidlMethod& method, const string& proxy_args_str) {
  string method_name = method.GetName();
  string return_type = JavaSignatureOf(method.GetType());
  bool is_void = (method.GetType().GetName() == "void");

  string callback_str;

  callback_str += "if (mTargetService != null) {\n";

  if (is_void) {
    callback_str += StringPrintf("  mTargetService.%s(%s);\n", method_name.c_str(), proxy_args_str.c_str());
  } else {
    callback_str += StringPrintf("  %s ret = mTargetService.%s(%s);\n", return_type.c_str(), method_name.c_str(), proxy_args_str.c_str());
    callback_str += "  mLogger.write(\"" + method_name + "() returning: \" + ret);\n";
    callback_str += "  return ret;\n";
  }

  callback_str += "} else {\n";
  callback_str += "  mLogger.write(\"Target service is not available yet\");\n";
  callback_str += "  throw new IllegalStateException(\"Target service is not available\");\n";
  callback_str += "}\n";

  return callback_str;
}


static shared_ptr<ClassElement> GenerateAIDLMethod(const AidlMethod& method) {
  auto aidl_method = CreateMethodSkeleton(method);
  const auto& args = method.GetArguments();

  ArgProcessingResult arg_result = ProcessArguments(args);

  string proxy_callback_code = arg_result.proxy_callback_code;
  string logging_code = GenerateMethodLoggingCode(method, arg_result.log_args_str);
  string vm_service_call_code = GenerateVmServiceCallCode(method, arg_result.proxy_args_str);

  std::ostringstream statement;
  statement << logging_code;
  statement << proxy_callback_code;
  statement << vm_service_call_code;

  string full_method_name = "mBinder." + method.GetName();
  if (method.GetType().GetName() == "void") {
    statement << "mLogger.write(\"" << full_method_name << "()\");\n";
  }

  aidl_method->statements->Add(std::make_shared<LiteralStatement>(statement.str()));
  return aidl_method;
}


static void GenerateStubInstance(const AidlInterface* iface,
                                 std::shared_ptr<Class> default_class) {
  string binder_instance = "\nprivate final " + iface->GetName() + ".Stub mBinder = new " + iface->GetName() + ".Stub() {\n";

  default_class->elements.emplace_back(std::make_shared<LiteralClassElement>(binder_instance));

  for (const auto& m : iface->GetMethods()) {
    if (m->IsUserDefined()) {
      default_class->elements.emplace_back(GenerateAIDLMethod(*m));
    } else {
        AIDL_ERROR(TAG.c_str()) << "method is not user-defined";
    }
  }

  default_class->elements.emplace_back(std::make_shared<LiteralClassElement>("};\n"));
}

static void GenerateClass(CodeWriter& out, const AidlDefinedType& defined_type,
                          const Options& options) {
  const string class_name = defined_type.GetCCServiceClassName();
  const AidlInterface* iface = defined_type.AsInterface();
  auto default_class = std::make_shared<Class>();

  AIDL_WARN(TAG.c_str()) << "GenerateClass start. OutputDir: " << options.OutputDir();
  if (iface == nullptr) {
    AIDL_ERROR(TAG.c_str()) << "interface is null";
    return;
  }

  default_class->modifiers = PUBLIC;
  default_class->what = Class::CLASS;
  default_class->type = defined_type.GetCCServiceFQCN();
  default_class->extends = "Service";
  default_class->interfaces.push_back("VmManager.VmServiceCallback");
  default_class->elements.emplace_back(GenerateMemberVariables(class_name, iface->GetName()));

  GenerateStubInstance(iface, default_class);

  default_class->elements.emplace_back(GenerateOnCreateMethod());
  default_class->elements.emplace_back(GenerateOnBindMethod());
  default_class->elements.emplace_back(GenerateOnUnBindMethod());
  default_class->elements.emplace_back(GenerateOnDestroyMethod());
  default_class->elements.emplace_back(GenerateVmServiceCallbackMethods(iface->GetName()));

  AIDL_WARN(TAG.c_str()) << "GenerateClass->Write start";
  default_class->Write(&out);
  AIDL_WARN(TAG.c_str()) << "GenerateProxyService: GenerateClass->Write done";
}

void GenerateAndroidManifest(const Options& options,
                  const AidlDefinedType& defined_type, const IoDelegate& io_delegate) {
  string output_file_name = options.OutputFile();
  string output_file_path = get_output_path(options, output_file_name);
  string class_name = defined_type.GetCCServiceClassName();

  output_file_name = output_file_path + "AndroidManifest.xml";
  CodeWriterPtr code_writer = io_delegate.GetCodeWriter(output_file_name);
  auto& out = *code_writer;
  out << R"(<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
)";

  out << "    package=\"" + defined_type.GetCCServicePackage() + "\">\n";

  out << R"(
    <uses-permission android:name="android.permission.MANAGE_VIRTUAL_MACHINE" />
    <uses-permission android:name="android.permission.USE_CUSTOM_VIRTUAL_MACHINE" />
    <uses-feature android:name="android.software.virtualization_framework" android:required="true" />
    <application>
)";
  out << "        <service android:name=\"." + class_name + "\"";
  out << R"(
                 android:enabled="true"
                 android:exported="true">
            <intent-filter>
)";
  out << "                <action android:name=\"" + defined_type.GetCCServiceFQCN() + "\" />";
  out << R"(
            </intent-filter>
        </service>
    </application>

</manifest>)";

  AIDL_FATAL_IF(!code_writer->Close(), defined_type) << "I/O Error!";

  AIDL_WARN("GenerateAndroidManifest is done");
}

void GenerateProxyService(const Options& options,
                  const AidlDefinedType& defined_type, const IoDelegate& io_delegate) {
  const string class_name = defined_type.GetCCServiceClassName();
  string output_file_name = options.OutputFile();
  string output_file_path = get_output_path(options, output_file_name);

  if (output_file_path.empty() && output_file_name.empty()) {
    AIDL_ERROR(TAG.c_str()) << "output file & output directory are empty";
    return;
  }

  output_file_name = GetProxyServiceFilePath(output_file_path, options, class_name);

  CodeWriterPtr code_writer = io_delegate.GetCodeWriter(output_file_name);

  /* write header */ {
    auto& out = *code_writer;

    GenerateAutoGenHeader(out, options);

    if (const auto pkg = defined_type.GetCCServicePackage(); !pkg.empty()) {
      out << "package " << pkg << ";\n";
    }

    GenerateImports(out, defined_type);
  }

  GenerateClass(*code_writer, defined_type, options);
  AIDL_FATAL_IF(!code_writer->Close(), defined_type) << "I/O Error!";

  AIDL_WARN("GenerateProxyService is done");
}

}  // namespace java
}  // namespace aidl
}  // namespace android