public static void setPlacementId(String pid)
{
//This function will be used to change the gameObjectName.
//In our sample project, Gameobject is "Main Camera" which has script "CallAirpush.cs" and it contain all callback listeners.
//You need to set the name of game object which contains all callback listeners
// again, make sure the thread is attached..
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
// create a JavaClass object...
IntPtr cls_JavaClass = JNI.FindClass("com/airpush/unity/MainActivity");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
// create a global reference to the JavaClass object and fetch method id(s)..
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
BtnMyAppWall = JNI.GetMethodID(cls_JavaClass, "setPlacementId", "(Ljava/lang/String;)V");
JNI.CallObjectMethod(JavaClass, BtnMyAppWall, JNI.NewStringUTF(pid));
}
public DebugProtocolService(JavaVM virtualMachine)
{
Contract.Requires<ArgumentNullException>(virtualMachine != null, "virtualMachine");
_virtualMachine = virtualMachine;
_eventProcessor = new EventProcessor(this);
JniErrorHandler.ThrowOnFailure(_virtualMachine.GetEnvironment(out _environment));
jvmtiCapabilities previousCapabilities;
JvmtiErrorHandler.ThrowOnFailure(_environment.GetCapabilities(out previousCapabilities));
var capabilities =
new jvmtiCapabilities(
jvmtiCapabilities.CapabilityFlags1.CanTagObjects
| jvmtiCapabilities.CapabilityFlags1.CanGetSyntheticAttribute
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName
| jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceDebugExtension
| jvmtiCapabilities.CapabilityFlags1.CanAccessLocalVariables
| jvmtiCapabilities.CapabilityFlags1.CanGenerateSingleStepEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateExceptionEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateBreakpointEvents
| jvmtiCapabilities.CapabilityFlags1.CanGetBytecodes
| jvmtiCapabilities.CapabilityFlags1.CanSuspend
);
JvmtiErrorHandler.ThrowOnFailure(RawInterface.AddCapabilities(_environment, ref capabilities));
}
public static void startAirBannerAdBottom()
{
// again, make sure the thread is attached..
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
// create a JavaClass object...
IntPtr cls_JavaClass = JNI.FindClass("com/airpush/unity/MainActivity");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
BtnMyAppWall = JNI.GetMethodID(cls_JavaClass, "airBannerAdBottom", "()V");
// get the Java String object from the JavaClass object
JNI.CallObjectMethod(JavaClass, BtnMyAppWall, JNI.NewStringUTF("top"));
}
public void TestMethod1()
{
Setup();
// NO FUNCIONA... ?????
JavaVMOption options = new JavaVMOption();
//options.optionString = $@"-Djava.class.path={jdkPath}";
options.optionString = "";
JavaVMInitArgs vm_args = JavaVMInitArgs.create(JNI.JNI_VERSION_1_8, 1);
vm_args.set(0, options);
int flags;
Ref_JavaVM refJavaVM = new Ref_JavaVM();
Ref_JNIEnv refJNIEnv = new Ref_JNIEnv();
flags = JavaVM.CreateJavaVM(refJavaVM, refJNIEnv, vm_args);
if (flags == JNI.JNI_ERR)
{
String msg = "Error creando la maquina virtual";
Debug.WriteLine(msg);
throw new Exception(msg);
}
JNIEnv jniEnv = refJNIEnv.getValue();
JClass clazz = jniEnv.FindClass("java/lang/Object");
Debug.WriteLine("Class " + clazz);
}
public jvmtiError GetSourceFileName(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out string sourceName)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
string sourceNameResult = null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr sourceNamePtr = IntPtr.Zero;
try
{
result = rawInterface.GetSourceFileName(environment.Handle, @class, out sourceNamePtr);
unsafe
{
if (sourceNamePtr != IntPtr.Zero)
{
sourceNameResult = ModifiedUTF8Encoding.GetString((byte *)sourceNamePtr);
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, sourceNamePtr);
}
});
sourceName = sourceNameResult;
return(result);
}
void Start()
{
// Attach our thread to the java vm; obviously the main thread is already attached but this is good practice..
JavaVM.AttachCurrentThread();
// Enable logging for debugging.
AndroidJavaClass tapjoyLog = new AndroidJavaClass("com.tapjoy.TapjoyLog");
tapjoyLog.CallStatic("enableLogging", true);
// Get the activity context for Android.
AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
currentActivity = jc.GetStatic <AndroidJavaObject>("currentActivity");
// Connect to the Tapjoy servers.
tapjoyConnect = new AndroidJavaClass("com.tapjoy.TapjoyConnect");
tapjoyConnect.CallStatic("requestTapjoyConnect",
currentActivity, // Activity context.
"acd01aa3-04f3-4a40-bae5-21affbf9bf86", // YOUR APP ID GOES HERE
"cQWKWp5HgYZuKGZQLAa0"); // YOUR SECRET KEY GOES HERE
tapjoyConnectInstance = tapjoyConnect.CallStatic <AndroidJavaObject>("getTapjoyConnectInstance");
tapjoyConnectInstance.Call("initVideoAd");
}
public jvmtiError GetThreadInfo(JvmVirtualMachineRemoteHandle virtualMachine, JvmThreadRemoteHandle thread, out JvmThreadRemoteInfo info)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiThreadInfo threadInfo = default(jvmtiThreadInfo);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetThreadInfo(environment.Handle, thread, out threadInfo);
});
info = new JvmThreadRemoteInfo()
{
Name = threadInfo.Name,
Priority = threadInfo._priority,
IsDaemon = threadInfo._isDaemon != 0,
ContextClassLoader = new JvmObjectRemoteHandle(threadInfo._contextClassLoader),
ThreadGroup = new JvmThreadGroupRemoteHandle(threadInfo._threadGroup)
};
return(result);
}
public JavaVM get(int i)
{
global::System.IntPtr cPtr = JNIPINVOKE.Buffer_JavaVM_get(swigCPtr, i);
JavaVM ret = (cPtr == global::System.IntPtr.Zero) ? null : new JavaVM(cPtr, false);
return(ret);
}
public JavaVM getValue()
{
global::System.IntPtr cPtr = JNIPINVOKE.Ref_JavaVM_getValue(swigCPtr);
JavaVM ret = (cPtr == global::System.IntPtr.Zero) ? null : new JavaVM(cPtr, false);
return(ret);
}
void Start()
{
// attach our thread to the java vm; obviously the main thread is already attached but this is good practice..
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
IntPtr obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
Debug.Log("obj_Activity = " + obj_Activity);
// create a JavaClass object...
IntPtr cls_JavaClass = JNI.FindClass("org/example/ScriptBridge/JavaClass");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
Debug.Log("JavaClass object = " + obj_JavaClass);
// create a global reference to the JavaClass object and fetch method id(s)..
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
getActivityCacheDir = JNI.GetMethodID(cls_JavaClass, "getActivityCacheDir", "()Ljava/lang/String;");
Debug.Log("JavaClass global ref = " + JavaClass);
Debug.Log("JavaClass method id = " + getActivityCacheDir);
}
private JvmtiEnvironment(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
Contract.Requires<ArgumentNullException>(virtualMachine != null, "virtualMachine");
_virtualMachine = virtualMachine;
_handle = handle;
_rawInterface = (jvmtiInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(handle.Handle), typeof(jvmtiInterface));
jvmtiCapabilities previousCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out previousCapabilities));
jvmtiCapabilities potentialCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetPotentialCapabilities(this, out potentialCapabilities));
var capabilities =
new jvmtiCapabilities(
jvmtiCapabilities.CapabilityFlags1.CanTagObjects
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName
| jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceDebugExtension
| jvmtiCapabilities.CapabilityFlags1.CanAccessLocalVariables
| jvmtiCapabilities.CapabilityFlags1.CanGenerateSingleStepEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateExceptionEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateBreakpointEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateFramePopEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateAllClassHookEvents
| jvmtiCapabilities.CapabilityFlags1.CanGetBytecodes
| jvmtiCapabilities.CapabilityFlags1.CanSuspend,
jvmtiCapabilities.CapabilityFlags2.CanGetConstantPool
);
JvmtiErrorHandler.ThrowOnFailure(RawInterface.AddCapabilities(this, ref capabilities));
jvmtiCapabilities newCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out newCapabilities));
}
public jvalue(JavaVM virtualMachine, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, Value value)
: this()
{
if (value.Data == 0)
return;
switch (value.Tag)
{
case Tag.Byte:
ByteValue = (byte)value.Data;
break;
case Tag.Char:
CharValue = (char)value.Data;
break;
case Tag.Float:
IntValue = (int)(uint)value.Data;
break;
case Tag.Int:
IntValue = (int)value.Data;
break;
case Tag.Double:
LongValue = (long)(ulong)value.Data;
break;
case Tag.Long:
LongValue = value.Data;
break;
case Tag.Short:
ShortValue = (short)value.Data;
break;
case Tag.Boolean:
break;
case Tag.Array:
case Tag.Object:
case Tag.String:
case Tag.Thread:
case Tag.ThreadGroup:
case Tag.ClassLoader:
case Tag.ClassObject:
if (value.Data == 0)
return;
ObjectValue = virtualMachine.GetLocalReferenceForObject(nativeEnvironment, new ObjectId(value.Data)).Value;
break;
case Tag.Void:
case Tag.Invalid:
default:
throw new ArgumentException();
}
}
internal static JvmEnvironment GetOrCreateEnvironment(JavaVM virtualMachine, jvmtiEnvHandle env)
{
Contract.Requires <ArgumentNullException>(virtualMachine != null, "virtualMachine");
JvmEnvironment environment = _environments.GetOrAdd(env, CreateEnvironment);
if (environment.VirtualMachine == null)
{
environment.VirtualMachine = virtualMachine;
}
return(environment);
}
private bool InitalizeAndroidSoundBankIO()
{
JavaVM.AttachCurrentThread();
// Find main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
IntPtr obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
if (obj_Activity == IntPtr.Zero)
{
Debug.LogError("WwiseUnity: Failed to get UnityPlayer activity. Abort.");
return(false);
}
// Create a JavaClass object...
const string AkPackageClass = "com/audiokinetic/aksoundengine/SoundBankIOInitalizerJavaClass";
IntPtr cls_JavaClass = JNI.FindClass(AkPackageClass);
if (cls_JavaClass == IntPtr.Zero)
{
Debug.LogError("WwiseUnity: Failed to find Java class. Check if plugin JAR file is available in Assets/Plugins/Android. Abort.");
return(false);
}
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
// Create a global reference to the JavaClass object and fetch method id(s)..
IntPtr soundBankIOInitalizerJavaClass = JNI.NewGlobalRef(obj_JavaClass);
int setAssetManagerMethodID = JNI.GetMethodID(cls_JavaClass, "SetAssetManager", "()I");
if (setAssetManagerMethodID == 0)
{
Debug.LogError("WwiseUnity: Failed to find Java class method. Check method name and signature in JNI query. Abort.");
return(false);
}
// get the Java String object from the JavaClass object
IntPtr ret = JNI.CallObjectMethod(soundBankIOInitalizerJavaClass, setAssetManagerMethodID);
if (ret != IntPtr.Zero)
{
Debug.LogError("WwiseUnity: Failed to set AssetManager for Android SoundBank low-level IO handler.");
return(false);
}
return(true);
}
public jvmtiError Deallocate(JvmVirtualMachineRemoteHandle virtualMachine, long address)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.Deallocate(environment.Handle, (IntPtr)address);
});
return(result);
}
public jvmtiError SetTag(JvmVirtualMachineRemoteHandle virtualMachine, JvmObjectRemoteHandle @object, long tag)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.SetTag(environment.Handle, @object, tag);
});
return(result);
}
public jvmtiError Allocate(JvmVirtualMachineRemoteHandle virtualMachine, long size, out long address)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiError result = jvmtiError.Internal;
IntPtr memory = IntPtr.Zero;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.Allocate(environment.Handle, size, out memory);
});
address = memory.ToInt64();
return(result);
}
public jvmtiError GetThreadState(JvmVirtualMachineRemoteHandle virtualMachine, JvmThreadRemoteHandle thread, out jvmtiThreadState threadState)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jvmtiThreadState threadStateResult = jvmtiThreadState.None;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetThreadState(environment.Handle, thread, out threadStateResult);
});
threadState = threadStateResult;
return(result);
}
public jvmtiError GetObjectHashCode(JvmVirtualMachineRemoteHandle virtualMachine, JvmObjectRemoteHandle @object, out int hashCode)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
int hashCodeResult = 0;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetObjectHashCode(environment.Handle, @object, out hashCodeResult);
});
hashCode = hashCodeResult;
return(result);
}
public jvmtiError GetCurrentThread(JvmVirtualMachineRemoteHandle virtualMachine, out JvmThreadRemoteHandle threadHandle)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
jthread thread = jthread.Null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
result = rawInterface.GetCurrentThread(environment.Handle, out thread);
});
threadHandle = new JvmThreadRemoteHandle(thread);
return(result);
}
protected override void Login(string facebookAppID)
{
JavaVM.AttachCurrentThread();
//Find current Activity
IntPtr clsActivity = JNI.FindClass("com/unity3d/player/UnityPlayer");
IntPtr objActivity = JNI.GetStaticObjectField(clsActivity, JNI.GetStaticFieldID(clsActivity, "currentActivity", "Landroid/app/Activity;"));
//Create LoginAdapter obj
IntPtr clsLAdapter = JNI.FindClass("com/socialnetwork/LoginAdapter");
IntPtr objlAdapter = JNI.NewObject(clsLAdapter, JNI.GetMethodID(clsLAdapter, "<init>", "(Landroid/app/Activity;)V"), objActivity);
IntPtr lAdapter = JNI.NewGlobalRef(objlAdapter);
if (JNI.CallBooleanMethod(lAdapter, JNI.GetMethodID(clsLAdapter, "Login", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z"), JNI.NewStringUTF(facebookAppID), JNI.NewStringUTF(host), JNI.NewStringUTF(port.ToString()), JNI.NewStringUTF("fb")) == 0)
{
return;
}
socketServer = new SocketServer(port);
socketServer.ReadString += OnLoginEnded;
}
public void TestMethod1()
{
Setup();
es.jni.JavaVMOption options = new JavaVMOption();
//options.optionString = $@"-Djava.class.path={jdkPath}";
options.optionString = "";
JavaVMInitArgs vm_args = JavaVMInitArgs.create(JNI.JNI_VERSION_1_8, 1);
vm_args.set(0, options);
int flags;
Ref_JavaVM refJavaVM = new Ref_JavaVM();
Ref_JNIEnv refJNIEnv = new Ref_JNIEnv();
flags = JavaVM.CreateJavaVM(refJavaVM, refJNIEnv, vm_args);
if (flags == JNI.JNI_ERR)
{
String msg = "Error creando la maquina virtual";
Debug.WriteLine(msg);
throw new Exception(msg);
}
JavaVM javaVM = refJavaVM.getValue();
JNIEnv jniEnv = refJNIEnv.getValue();
JClass jclazz = jniEnv.FindClass("java/lang/Object");
Debug.WriteLine("jclazz " + jclazz);
GC(jniEnv);
JMethodID jinit = jniEnv.GetMethodID(jclazz, "<init>", "()V");
JObject jinstance = jniEnv.NewObject(jclazz, jinit, new JValue[0]);
JObject jref = jniEnv.NewGlobalRef(jinstance);
Test(jniEnv, jclazz);
jniEnv.DeleteLocalRef(jclazz);
}
public jvmtiError GetClassSignature(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out string signature, out string generic)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
string signatureResult = null;
string genericResult = null;
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr signaturePtr = IntPtr.Zero;
IntPtr genericPtr = IntPtr.Zero;
try
{
result = rawInterface.GetClassSignature(environment.Handle, @class, out signaturePtr, out genericPtr);
unsafe
{
if (signaturePtr != IntPtr.Zero)
{
signatureResult = ModifiedUTF8Encoding.GetString((byte *)signaturePtr);
}
if (genericPtr != IntPtr.Zero)
{
genericResult = ModifiedUTF8Encoding.GetString((byte *)genericPtr);
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, signaturePtr);
rawInterface.Deallocate(environment.Handle, genericPtr);
}
});
signature = signatureResult;
generic = genericResult;
return(result);
}
public static void startAirIconAd()
{
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
IntPtr cls_JavaClass = JNI.FindClass("com/airpush/unity/MainActivity");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
BtnMyIcon = JNI.GetMethodID(cls_JavaClass, "airiconAd", "()V");
Debug.Log("parul6");
// get the Java String object from the JavaClass object
JNI.CallObjectMethod(JavaClass, BtnMyIcon, JNI.NewStringUTF("Caching"));
}
private string getCacheDir()
{
// again, make sure the thread is attached..
JavaVM.AttachCurrentThread();
// get the Java String object from the JavaClass object
IntPtr str_cacheDir = JNI.CallObjectMethod(JavaClass, getActivityCacheDir);
Debug.Log("str_cacheDir = " + str_cacheDir);
// convert the Java String into a Mono string
IntPtr stringPtr = JNI.GetStringUTFChars(str_cacheDir, 0);
Debug.Log("stringPtr = " + stringPtr);
String cache = Marshal.PtrToStringAnsi(stringPtr);
JNI.ReleaseStringUTFChars(str_cacheDir, stringPtr);
Debug.Log("return value is = " + cache);
return(cache);
}
// Use this for initialization
public static void startAirSmartWallAd()
{
// This method can be directly called to show the smartwall ad directly without caching.
// again, make sure the thread is attached..
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
IntPtr cls_JavaClass = JNI.FindClass("com/airpush/unity/MainActivity");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
BtnMySmart = JNI.GetMethodID(cls_JavaClass, "airSmartWallAd", "()V");
// get the Java String object from the JavaClass object
JNI.CallObjectMethod(JavaClass, BtnMySmart, JNI.NewStringUTF("Caching"));
}
public jvmtiError GetClassMethods(JvmVirtualMachineRemoteHandle virtualMachine, JvmClassRemoteHandle @class, out JvmMethodRemoteHandle[] methods)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
List <JvmMethodRemoteHandle> methodsList = new List <JvmMethodRemoteHandle>();
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr methodsPtr = IntPtr.Zero;
try
{
int methodCount;
result = rawInterface.GetClassMethods(environment.Handle, @class, out methodCount, out methodsPtr);
unsafe
{
jmethodID *rawMethods = (jmethodID *)methodsPtr;
for (int i = 0; i < methodCount; i++)
{
methodsList.Add(new JvmMethodRemoteHandle(rawMethods[i]));
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, methodsPtr);
}
});
methods = methodsList.ToArray();
return(result);
}
public jvmtiError GetLineNumberTable(JvmVirtualMachineRemoteHandle virtualMachine, JvmMethodRemoteHandle method, out JvmLineNumberEntry[] lineNumbers)
{
JavaVM machine = JavaVM.GetInstance(virtualMachine);
List <JvmLineNumberEntry> lineNumbersList = new List <JvmLineNumberEntry>();
jvmtiError result = jvmtiError.Internal;
machine.InvokeOnJvmThread(
(environment) =>
{
jvmtiInterface rawInterface = environment.RawInterface;
IntPtr lineNumbersPtr = IntPtr.Zero;
try
{
int entryCount;
result = rawInterface.GetLineNumberTable(environment.Handle, (jmethodID)method, out entryCount, out lineNumbersPtr);
unsafe
{
jvmtiLineNumberEntry *rawLineNumbers = (jvmtiLineNumberEntry *)lineNumbersPtr;
for (int i = 0; i < entryCount; i++)
{
lineNumbersList.Add(new JvmLineNumberEntry(method, rawLineNumbers[i]));
}
}
}
finally
{
rawInterface.Deallocate(environment.Handle, lineNumbersPtr);
}
});
lineNumbers = lineNumbersList.ToArray();
return(result);
}
// Use this for initialization
public static void showCachedAirSmartWallAd()
{
// This method will be used to show the ad which has been cached by cacheAirSmartWallAd
//This method will be used in conjunction with cacheAirSmartWallAd and should be called only after cacheAirSmartWallAd
// again, make sure the thread is attached..
JavaVM.AttachCurrentThread();
// first we try to find our main activity..
IntPtr cls_Activity = JNI.FindClass("com/unity3d/player/UnityPlayer");
int fid_Activity = JNI.GetStaticFieldID(cls_Activity, "currentActivity", "Landroid/app/Activity;");
obj_Activity = JNI.GetStaticObjectField(cls_Activity, fid_Activity);
IntPtr cls_JavaClass = JNI.FindClass("com/airpush/unity/MainActivity");
int mid_JavaClass = JNI.GetMethodID(cls_JavaClass, "<init>", "(Landroid/app/Activity;)V");
IntPtr obj_JavaClass = JNI.NewObject(cls_JavaClass, mid_JavaClass, obj_Activity);
JavaClass = JNI.NewGlobalRef(obj_JavaClass);
BtnMySmart = JNI.GetMethodID(cls_JavaClass, "airShowCachedAd", "()V");
// get the Java String object from the JavaClass object
JNI.CallObjectMethod(JavaClass, BtnMySmart, JNI.NewStringUTF("Cached"));
}
public void setValue(JavaVM pvalue)
{
JNIPINVOKE.Ref_JavaVM_setValue(swigCPtr, JavaVM.getCPtr(pvalue));
}
private bool ShouldSkipCurrentMethod(JavaVM virtualMachine, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jthread thread, int stackDepth, Location location, out bool convertToFramePop)
{
Contract.Assert(_depth == StepDepth.Into || _depth == StepDepth.Over);
convertToFramePop = false;
if (!_hasMethodInfo || stackDepth < _stackDepth || (stackDepth == _stackDepth && (location.Method.Equals(_lastMethod))))
return false;
/*
* change this to a Frame Pop event if we're not in a native frame
*/
bool native;
jvmtiError error = environment.IsMethodNative(location.Method, out native);
if (error != jvmtiError.None)
return false;
convertToFramePop = !native;
if (_depth == StepDepth.Over || native)
return true;
JvmAccessModifiers modifiers;
error = environment.GetMethodModifiers(location.Method, out modifiers);
if (error != jvmtiError.None || ((modifiers & JvmAccessModifiers.Static) != 0))
return false;
jobject thisObject;
error = environment.GetLocalObject(thread, 0, 0, out thisObject);
if (error != jvmtiError.None)
return false;
try
{
bool classLoader = nativeEnvironment.IsInstanceOf(thisObject, virtualMachine.ClassLoaderClass);
if (!classLoader)
return false;
string name;
string signature;
string genericSignature;
error = environment.GetMethodName(location.Method, out name, out signature, out genericSignature);
if (error != jvmtiError.None)
return false;
if (name == "loadClass" && signature == "(Ljava/lang/String;)Ljava/lang/Class;")
return true;
if (name == "checkPackageAccess" && signature == "(Ljava/lang/Class;Ljava/security/ProtectionDomain;)V")
return true;
return false;
}
finally
{
nativeEnvironment.DeleteLocalReference(thisObject);
}
}
private static JvmtiEnvironment CreateVirtualMachine(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
return new JvmtiEnvironment(virtualMachine, handle);
}
internal static JvmtiEnvironment GetOrCreateInstance(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
return _instances.GetOrAdd(handle, i => CreateVirtualMachine(virtualMachine, i));
}
private static void GetEnvironmentVersion(JavaVM vm)
{
JvmtiEnvironment env;
int error = vm.GetEnvironment(out env);
int version;
jvmtiError error2 = env.GetVersionNumber(out version);
}
/// <summary>
/// Create the Java VM and wrap it.
/// </summary>
/// <param name="jvmDllPath">(Optional) Path to jvm.dll where we'll load the JNI library. If not provided we'll try to infer its location from the Java install path.</param>
/// <param name="attemptVmReuse">
/// This is an annoying workaround to a fundamental JNI problem: you can't host a JVM within the process again once you've hosted it once
/// (ever, even if you destroy the first one). So if this flag is <c>true</c>, we'll attempt to find an existing JVM in the process and use that
/// if available, and we won't destroy the JVM on dispose so subsequent constructions of this object will succeed.
/// The downside of reuse of course is that if we're reusing it then we won't be able to construct it with fresh arguments.
/// </param>
internal JniWrapper(string jvmDllPath, bool attemptVmReuse, IEnumerable <JavaOption> options)
{
_currentThreadEnv = new ThreadLocal <IntPtr>(() =>
{
IntPtr ret;
unsafe
{
if (_vm.GetDelegate <GetEnv>()(_vmP, (IntPtr)(&ret), _jniVersion) == -2)
{
_vm.GetDelegate <AttachCurrentThread>()(_vmP, (IntPtr)(&ret), IntPtr.Zero);
}
return(ret);
}
});
if (String.IsNullOrEmpty(jvmDllPath))
{
string javaHome = GetJavaInstallationPath();
_vmDll = Path.Combine(javaHome, "bin", "server", "jvm.dll");
}
else
{
_vmDll = jvmDllPath;
}
if (!File.Exists(_vmDll))
{
throw new InvalidOperationException("Couldn't find the runtime library for Java at: " + _vmDll);
}
IntPtr envP;
IntPtr vmP;
_vmDllModule = LoadLibrary(_vmDll);
if (_vmDllModule == IntPtr.Zero)
{
throw new Win32Exception();
}
if (attemptVmReuse)
{
_vmReuse = true;
int numVms;
unsafe
{
ThrowOnBadResult(GetDelegateFromJni <GetCreatedJavaVMs>("JNI_GetCreatedJavaVMs")(&vmP, 1, out numVms), "GetCreatedJavaVMs");
if (numVms >= 1)
{
_vmP = vmP;
_vm = (JavaVM)Marshal.PtrToStructure(vmP, typeof(JavaVM));
ThrowOnBadResult(_vm.GetDelegate <AttachCurrentThread>()(_vmP, (IntPtr)(&envP), IntPtr.Zero), "AttachCurrentThread");
_envP = envP;
_env = (JniEnv)Marshal.PtrToStructure(envP, typeof(JniEnv));
return;
}
}
}
JavaVMInitArgs vmArgs = new JavaVMInitArgs();
GetDelegateFromJni <GetDefaultJavaVMInitArgs>("JNI_GetDefaultJavaVMInitArgs")(ref vmArgs);
vmArgs.Version = _jniVersion;
vmArgs._nOptions = options.Count();
vmArgs._options = Marshal.AllocHGlobal(vmArgs._nOptions * Marshal.SizeOf(typeof(JavaVMOption)));
IntPtr vmArgsP = Marshal.AllocHGlobal(Marshal.SizeOf(vmArgs));
try
{
int optionsLocation = 0;
foreach (JavaOption currentOption in options)
{
Marshal.StructureToPtr(currentOption.ActualOption, vmArgs._options + optionsLocation * Marshal.SizeOf(typeof(JavaVMOption)), false);
optionsLocation++;
}
Marshal.StructureToPtr(vmArgs, vmArgsP, false);
unsafe
{
ThrowOnBadResult(GetDelegateFromJni <CreateJavaVM>("JNI_CreateJavaVM")(&vmP, &envP, vmArgsP), "CreateJavaVM");
_vm = (JavaVM)Marshal.PtrToStructure(vmP, typeof(JavaVM));
_env = (JniEnv)Marshal.PtrToStructure(envP, typeof(JniEnv));
_envP = envP;
_vmP = vmP;
}
}
finally
{
Marshal.DestroyStructure(vmArgsP, typeof(JavaVMInitArgs));
Marshal.FreeHGlobal(vmArgsP);
Marshal.FreeHGlobal(vmArgs._options);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(JavaVM obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public JniGlobalHandle(JniGlobalHandleNs handleValue, JavaVM javaVM)
: base(IntPtr.Zero, true)
{
this.javaVM = javaVM;
SetHandle(handleValue.handle);
}
