long f (int n, String s, float g); 

CallStaticMethod<long>(className, “f”, 1, 1.2f); 

Постановка задачи

1. Вызвать метод;
2. Из параметров нужно вытянуть строку сигнатуры. Да, да, вот эту (ILjava/lang/String;F)J;
3. Сконвертировать параметры в нужный тип;
4. Возвратить тип данных, который хочет видеть пользователь нашего класса.

Вызов метода

template <typename MethodType, typename... Args>
MethodType CallStaticMethod(Args... args);

Составляем сигнатуру

1. Используем typeid и цепочку if … else. Должно получится что-то вроде:
   

   if (typeid(arg) == typeid(int)) return “I”;
   else if (typeid(arg) == typeid(float)) return “F”;
   

   
   И так для всех типов, которые вам нужны.
2. Используем шаблоны и их частичные типизации. Метод интересен тем, что у вас будут функции в одну строку и не будет лишних сравнений типов. Более того все это будет на стадии инстанциации шаблонов. Выглядеть все будет примерно так:
   

   template <typename T>
   std::string GetTypeName();
   
   // int
   template <>
   std::string GetTypeName<int>() { return “I”; }
   
   // string
   template <>
   std::string GetTypeName<const char*>() { return “Ljava/lang/String;”; }
   

   
   

void GetTypeRecursive(std::string&)
    {   }

template <typename T, typename... Args>
void GetTypeRecursive(std::string& signatureString, T value, Args... args)
	{
	signatureString += GetTypeName<T>();
	GetTypeRecursive(signatureString, args...);
	}

template <typename MethodType, typename... Args>
MethodType CallStaticMethod(const char* className, const char* mname, Args... args)
{
    std::string signature_string = "(";
    GetTypeRecursive(signature_string, args...);
    signature_string += ")";
    signature_string += GetTypeName<MethodType>();
    return MethodType(); // пока здесь заглушка
}

template <typename MethodType, typename... Args>
MethodType CallStaticMethod(const char* className, const char* mname, Args... args)
{
    const size_t arg_num = sizeof...(Args);
    std::string signatures[arg_num] = { GetType(args)... };

    std::string signature_string;
    signature_string.reserve(15);
    signature_string += "(";
    for (size_t i = 0; i < arg_num; ++i)
   	signature_string += signatures[i];
    signature_string += ")";
    signature_string += GetTypeName<MethodType>();
     
    return MethodType(); // пока здесь заглушка
}

Конвертация типа данных

NativeType CallStatic<type>Method(JNIEnv *env, jclass clazz,
jmethodID methodID, ...);

NativeType CallStatic<type>MethodA(JNIEnv *env, jclass clazz,
jmethodID methodID, jvalue *args);

NativeType CallStatic<type>MethodV(JNIEnv *env, jclass clazz,
jmethodID methodID, va_list args);

struct JniHolder
        {
        jvalue val;
	JObjectHolder jObject;

        // bool
        explicit JniHolder(JNIEnv *env, bool arg)
            : jObject(env, jobject())
            {
            val.z = arg;
            }

        // byte
        explicit JniHolder(JNIEnv *env, unsigned char arg)
            : jObject(env, jobject())
            {
            val.b = arg;
            }

        // char
        explicit JniHolder(JNIEnv *env, char arg)
            : jObject(env, jobject())
            {
            val.c = arg;
            }

        // short
        explicit JniHolder(JNIEnv *env, short arg)
            : jObject(env, jobject())
            {
            val.s = arg;
            }

        // int
        explicit JniHolder(JNIEnv *env, int arg)
            : jObject(env, jobject())
            {
            val.i = arg;
            }

        // long
        explicit JniHolder(JNIEnv *env, long arg)
            : jObject(env, jobject())
            {
            val.j = arg;
            }

        // float
        explicit JniHolder(JNIEnv *env, float arg)
            : jObject(env, jobject())
            {
            val.f = arg;
            }

        // double
        explicit JniHolder(JNIEnv *env, double arg)
            : jObject(env, jobject())
            {
            val.d = arg;
            }

        // string
        explicit JniHolder(JNIEnv *env, const char* arg)
			: jObject(env, env->NewStringUTF(arg))
            {
            val.l = jObject.get();
            }

        // object
        explicit JniHolder(JNIEnv *env, jobject arg)
            : jObject(env, arg)
            {
            val.l = jObject.get();
            }

        ////////////////////////////////////////////////////////

		operator jvalue() { return val; }

        jvalue get() { return val; }
        };

struct JObjectHolder
	{
	jobject jObject;
	JNIEnv* m_env;

	JObjectHolder()
		: m_env(nullptr)
		{}

	JObjectHolder(JNIEnv* env, jobject obj)
		: jObject(obj)
		, m_env(env)
		{}

	~JObjectHolder()
		{
		if (jObject && m_env != nullptr)
			m_env->DeleteLocalRef(jObject);
		}

	jobject get() { return jObject; }
	};

jvalue val = static_cast<jvalue>(JniHolder(env, 10));

JniHolder holder(env, 10)
jvalue val = static_cast<jvalue>(holder);

JniHolder holders[size] = { std::move(JniHolder(env, args))... };
jvalue vals[size];
for (size_t i = 0; i < size; ++i)
	vals[i] = static_cast<jvalue>(holders[i]);

Возвращение нужного типа данных

template <typename MethodType, typename... Args>
MethodType CallStaticMethod(Args... args)
{
	MethodType result = ...;
	….
	return reesult;
}

template <typename MethodType>
struct Impl
	{
	template <typename... Args>
	static MethodType CallMethod(JNIEnv* env, jclass clazz, jmethodID method, Args... args);
	};

template <>
struct Impl <int>
	{
	template <typename... Args>
	static int CallStaticMethod(JNIEnv* env, jclass clazz, jmethodID method, Args... args)
		{
		const int size = sizeof...(args);
		if (size != 0)
			{
			jvalue vals[size] = { static_cast<jvalue>(JniHolder(env, args))... };
			return env->CallStaticIntMethodA(clazz, method, vals);
			}

		return env->CallStaticIntMethod(clazz, method);
		}
	};

Финал

template <typename MethodType, typename... Args>
MethodType CallStaticMethod(const char* className, const char* mname, Args... args)
	{
	const size_t arg_num = sizeof...(Args);
	std::string signatures[arg_num] = { GetType(args)... };

	std::string signature_string;
	signature_string.reserve(15);
	signature_string += "(";
	for (size_t i = 0; i < arg_num; ++i)
		signature_string += signatures[i];
	signature_string += ")";
	signature_string += GetTypeName<MethodType>();

	JNIEnv *env = getEnv();
	JniClass clazz(env, className);
	jmethodID method = env->GetStaticMethodID(clazz.get(), mname, signature_string.c_str());
	return Impl<MethodType>::CallStaticMethod(env, clazz.get(), method, args...);
	}

class Test {
public static float TestMethod(String par, float x)
	{
		mOutString += "float String: " + par + " float=" + x  + "\n";
		return x;
	}
};

float fRes = CallStaticMethod<float>("Test", "TestMethod", "TestString", 4.2f);

JNIEnv* env = getEnv(); // где-то надо достать эту штуку
jclass clazz = env->FindClass(“Test”);
jmethodID method = env->GetStaticMethodID(“Test”, “TestMethod”, “(Ljava/lang/String;F)Ljava/lang/String;);
jstring str = env->NewStringUTF(“TestString”);
float fRes = env->CallStaticFloatMethod(clazz, method, str, 4.2f);
env->DeleteLocalRef(clazz);
env->DeleteLocalRef(str);

Выводы