public static byte[] GenerateStub(jlClass c)
{
MemoryStream mem = new MemoryStream();
#if !FIRST_PASS
bool includeNonPublicInterfaces = !"true".Equals(global::java.lang.Props.props.getProperty("ikvm.stubgen.skipNonPublicInterfaces"), StringComparison.OrdinalIgnoreCase);
IKVM.StubGen.StubGenerator.WriteClass(mem, TypeWrapper.FromClass(c), includeNonPublicInterfaces, false, false, true);
#endif
return mem.ToArray();
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.builder.conf.@__KnowledgeBuilderOption.staticClass = @__class;
global::org.drools.builder.conf.@__KnowledgeBuilderOption._getPropertyName0 = @__env.GetMethodID(global::org.drools.builder.conf.@__KnowledgeBuilderOption.staticClass, "getPropertyName", "()Ljava/lang/String;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.lang.reflect.@__WildcardType.staticClass = @__class;
global::java.lang.reflect.@__WildcardType.j4n_getLowerBounds0 = @__env.GetMethodID(global::java.lang.reflect.@__WildcardType.staticClass, "getLowerBounds", "()[Ljava/lang/reflect/Type;");
global::java.lang.reflect.@__WildcardType.j4n_getUpperBounds1 = @__env.GetMethodID(global::java.lang.reflect.@__WildcardType.staticClass, "getUpperBounds", "()[Ljava/lang/reflect/Type;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.builder.@__KnowledgeBuilderError.staticClass = @__class;
global::org.drools.builder.@__KnowledgeBuilderError._getMessage0 = @__env.GetMethodID(global::org.drools.builder.@__KnowledgeBuilderError.staticClass, "getMessage", "()Ljava/lang/String;");
global::org.drools.builder.@__KnowledgeBuilderError._getErrorLines1 = @__env.GetMethodID(global::org.drools.builder.@__KnowledgeBuilderError.staticClass, "getErrorLines", "()[I");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.control.events.BattleFinishedEvent.staticClass = @__class;
global::robocode.control.events.BattleFinishedEvent.j4n_isAborted0 = @__env.GetMethodID(global::robocode.control.events.BattleFinishedEvent.staticClass, "isAborted", "()Z");
global::robocode.control.events.BattleFinishedEvent.j4n__ctorBattleFinishedEvent1 = @__env.GetMethodID(global::robocode.control.events.BattleFinishedEvent.staticClass, "<init>", "(Z)V");
}
internal object ToMethodOrConstructor(bool copy)
{
#if FIRST_PASS
return null;
#else
object method = reflectionMethod;
if (method == null)
{
Link();
ClassLoaderWrapper loader = this.DeclaringType.GetClassLoader();
TypeWrapper[] argTypes = GetParameters();
java.lang.Class[] parameterTypes = new java.lang.Class[argTypes.Length];
for (int i = 0; i < argTypes.Length; i++)
{
parameterTypes[i] = argTypes[i].EnsureLoadable(loader).ClassObject;
}
java.lang.Class[] checkedExceptions = GetExceptions();
if (this.Name == StringConstants.INIT)
{
method = new java.lang.reflect.Constructor(
this.DeclaringType.ClassObject,
parameterTypes,
checkedExceptions,
(int)this.Modifiers | (this.IsInternal ? 0x40000000 : 0),
Array.IndexOf(this.DeclaringType.GetMethods(), this),
this.DeclaringType.GetGenericMethodSignature(this),
null,
null
);
}
else
{
method = new java.lang.reflect.Method(
this.DeclaringType.ClassObject,
this.Name,
parameterTypes,
this.ReturnType.EnsureLoadable(loader).ClassObject,
checkedExceptions,
(int)this.Modifiers | (this.IsInternal ? 0x40000000 : 0),
Array.IndexOf(this.DeclaringType.GetMethods(), this),
this.DeclaringType.GetGenericMethodSignature(this),
null,
null,
null
);
}
lock (this)
{
if (reflectionMethod == null)
{
reflectionMethod = method;
}
else
{
method = reflectionMethod;
}
}
}
if (copy)
{
java.lang.reflect.Constructor ctor = method as java.lang.reflect.Constructor;
if (ctor != null)
{
return ctor.copy();
}
return ((java.lang.reflect.Method)method).copy();
}
return method;
#endif
}
public override global::System.Object getParameterTypes() {
org.xmlvm._nMemberInfoAdapter<global::System.Reflection.MethodInfo,
java.lang.reflect.Constructor._nImpl> adapter
= (org.xmlvm._nMemberInfoAdapter<global::System.Reflection.MethodInfo,
java.lang.reflect.Constructor._nImpl>) this._faddress;
global::System.Reflection.MethodInfo methodInfo = adapter.getMemberInfoAdaptee();
global::System.Reflection.ParameterInfo[] parameterInfos = methodInfo.GetParameters();
java.lang.Class[] parameterJavaTypes = new java.lang.Class[parameterInfos.Length];
for (int i=0; i<parameterInfos.Length; i++) {
global::System.Type parameterNativeType = parameterInfos[i].ParameterType;
parameterJavaTypes[i] = org.xmlvm._nTIB.getClass(parameterNativeType);
}
org.xmlvm._nArrayAdapter<object> result = new org.xmlvm._nArrayAdapter<object>(parameterJavaTypes);
return result;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.exception.AbortedException.staticClass = @__class;
global::robocode.exception.AbortedException.j4n__ctorAbortedException0 = @__env.GetMethodID(global::robocode.exception.AbortedException.staticClass, "<init>", "()V");
global::robocode.exception.AbortedException.j4n__ctorAbortedException1 = @__env.GetMethodID(global::robocode.exception.AbortedException.staticClass, "<init>", "(Ljava/lang/String;)V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.runtime.rule.@__Operator.staticClass = @__class;
global::org.drools.runtime.rule.@__Operator._getOperatorString0 = @__env.GetMethodID(global::org.drools.runtime.rule.@__Operator.staticClass, "getOperatorString", "()Ljava/lang/String;");
global::org.drools.runtime.rule.@__Operator._isNegated1 = @__env.GetMethodID(global::org.drools.runtime.rule.@__Operator.staticClass, "isNegated", "()Z");
}
public static bool IsDynamic(jlClass clazz)
{
return TypeWrapper.FromClass(clazz) is DynamicTypeWrapper;
}
public static Assembly GetAssemblyFromClass(jlClass clazz)
{
TypeWrapper wrapper = TypeWrapper.FromClass(clazz);
AssemblyClassLoader_ acl = wrapper.GetClassLoader() as AssemblyClassLoader_;
return acl != null ? acl.GetAssembly(wrapper) : null;
}
public static bool isClassDeprecated(jlClass clazz)
{
Type type = TypeWrapper.FromClass(clazz).TypeAsTBD;
// we need to check type for null, because ReflectionOnly
// generated delegate inner interfaces don't really exist
return type != null && type.IsDefined(typeof(ObsoleteAttribute), false);
}
public static string getAssemblyName(jlClass c)
{
TypeWrapper wrapper = TypeWrapper.FromClass(c);
ClassLoaderWrapper loader = wrapper.GetClassLoader();
IKVM.Internal.AssemblyClassLoader acl = loader as IKVM.Internal.AssemblyClassLoader;
if(acl != null)
{
return acl.GetAssembly(wrapper).FullName;
}
else
{
return ((IKVM.Internal.GenericClassLoader)loader).GetName();
}
}
public void setClass(java.lang.Class myClass)
{
this.myClass = myClass;
}
public _ResponseDeserializer_271(InternalArangoDatabase <E, R, C> _enclosing, java.lang.Class
type)
{
this._enclosing = _enclosing;
this.type = type;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::[email protected].@__KnowledgeBaseEvent.staticClass = @__class;
global::[email protected].@__KnowledgeBaseEvent._getKnowledgeBase0 = @__env.GetMethodID(global::[email protected].@__KnowledgeBaseEvent.staticClass, "getKnowledgeBase", "()Lorg/drools/KnowledgeBase;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.lang.@__Comparable.staticClass = @__class;
global::java.lang.@__Comparable._compareTo0 = @__env.GetMethodID(global::java.lang.@__Comparable.staticClass, "compareTo", "(Ljava/lang/Object;)I");
}
private static PlTerm typeToSpec(Class type)
{
if (type == null) return PLNULL;
if (type.IsArray && type.HasElementType)
{
if (type.GetArrayRank() != 1)
{
return PlC("arrayOf", typeToSpec(type.GetElementType()), ToProlog(type.GetArrayRank()));
}
return PlC("arrayOf", typeToSpec(type.GetElementType()));
}
if (type.IsGenericParameter)
{
Type[] gt = type.GetGenericParameterConstraints();
return PlC("<" + type.FullName ?? type.Name + ">", ToPlTermVSpecs(gt));
}
if (type.IsPointer)
{
Type gt = type.GetElementType();
return PlC("pointer", typeToSpec(gt));
}
if (type.IsByRef)
{
Type gt = type.GetElementType();
return PlC("byref", typeToSpec(gt));
}
// @todo if false , use IsGenericType
if (false) if (typeof(Nullable<>).IsAssignableFrom(type))
{
Error("@todo Not Implemented NULLABLE");
Type gt = type.GetElementType();
return PlC("nullable", typeToSpec(gt));
}
if (type.IsGenericType )
{
Type gt = type.GetGenericTypeDefinition();
Type[] gtp = type.GetGenericArguments();
PlTermV vt = ToPlTermVSpecs(gtp);
string typeName = type.FullName ?? type.Name;
int gtpLength = gtp.Length;
int indexOf = typeName.IndexOf("`" + gtpLength);
if (indexOf > 0)
{
typeName = typeName.Substring(0, indexOf);
}
else
{
Debug("cant chop arity {0} off string '{1}' ", gtpLength, typeName);
}
return PlC(typeName, vt);
}
if (type.HasElementType)
{
string named = typeToName(type);
Error("@todo Not Implemented " + named);
Type gt = type.GetElementType();
if (gt == type) gt = typeof(object);
return PlC("elementType", PlTerm.PlAtom(named), typeToSpec(gt));
}
if (type.IsSpecialName || string.IsNullOrEmpty(type.Name) || string.IsNullOrEmpty(type.FullName) || string.IsNullOrEmpty(type.Namespace))
{
string named = typeToName(type);
Error("@todo Not Implemented " + named);
Type gt = type.UnderlyingSystemType;
if (gt == type) gt = typeof (object);
return PlC("static", PlTerm.PlAtom(named), typeToSpec(gt));
}
return PlTerm.PlAtom(typeToName(type));
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.runtime.@__Calendars.staticClass = @__class;
global::org.drools.runtime.@__Calendars._get0 = @__env.GetMethodID(global::org.drools.runtime.@__Calendars.staticClass, "get", "(Ljava/lang/String;)Lorg/drools/time/Calendar;");
global::org.drools.runtime.@__Calendars._set1 = @__env.GetMethodID(global::org.drools.runtime.@__Calendars.staticClass, "set", "(Ljava/lang/String;Lorg/drools/time/Calendar;)V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::[email protected].@__ActivationEvent.staticClass = @__class;
global::[email protected].@__ActivationEvent._getKnowledgeRuntime0 = @__env.GetMethodID(global::[email protected].@__ActivationEvent.staticClass, "getKnowledgeRuntime", "()Lorg/drools/runtime/KnowledgeRuntime;");
global::[email protected].@__ActivationEvent._getActivation1 = @__env.GetMethodID(global::[email protected].@__ActivationEvent.staticClass, "getActivation", "()Lorg/drools/runtime/rule/Activation;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::net.sf.jni4net.jni.__IJvmProxy.staticClass = @__class;
global::net.sf.jni4net.jni.__IJvmProxy._JvmHandle0 = @__env.GetMethodID(global::net.sf.jni4net.jni.__IJvmProxy.staticClass, "getJvmHandle", "()J");
global::net.sf.jni4net.jni.__IJvmProxy._Init2 = @__env.GetMethodID(global::net.sf.jni4net.jni.__IJvmProxy.staticClass, "Init", "(Lsystem/Object;J)V");
}
internal override sealed TypeWrapper DefineClassImpl(Dictionary<string, TypeWrapper> types, ClassFile f, ClassLoaderWrapper classLoader, object protectionDomain)
{
DynamicTypeWrapper type;
#if STATIC_COMPILER
type = new AotTypeWrapper(f, (CompilerClassLoader)classLoader);
#else
type = new DynamicTypeWrapper(f, classLoader);
#endif
// this step can throw a retargettable exception, if the class is incorrect
bool hasclinit;
type.CreateStep1(out hasclinit);
// now we can allocate the mangledTypeName, because the next step cannot fail
string mangledTypeName = AllocMangledName(f.Name);
// This step actually creates the TypeBuilder. It is not allowed to throw any exceptions,
// if an exception does occur, it is due to a programming error in the IKVM or CLR runtime
// and will cause a CriticalFailure and exit the process.
type.CreateStep2NoFail(hasclinit, mangledTypeName);
lock(types)
{
// in very extreme conditions another thread may have beaten us to it
// and loaded (not defined) a class with the same name, in that case
// we'll leak the the Reflection.Emit defined type. Also see the comment
// in ClassLoaderWrapper.RegisterInitiatingLoader().
TypeWrapper race;
types.TryGetValue(f.Name, out race);
if(race == null)
{
lock(dynamicTypes)
{
Debug.Assert(dynamicTypes.ContainsKey(mangledTypeName) && dynamicTypes[mangledTypeName] == null);
dynamicTypes[mangledTypeName] = type;
}
types[f.Name] = type;
#if !STATIC_COMPILER && !FIRST_PASS
java.lang.Class clazz = new java.lang.Class(null);
#if __MonoCS__
TypeWrapper.SetTypeWrapperHack(clazz, type);
#else
clazz.typeWrapper = type;
#endif
clazz.pd = (java.security.ProtectionDomain)protectionDomain;
type.SetClassObject(clazz);
#endif
}
else
{
throw new LinkageError("duplicate class definition: " + f.Name);
}
}
return type;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.control.events.TurnEndedEvent.staticClass = @__class;
global::robocode.control.events.TurnEndedEvent.j4n_getTurnSnapshot0 = @__env.GetMethodID(global::robocode.control.events.TurnEndedEvent.staticClass, "getTurnSnapshot", "()Lrobocode/control/snapshot/ITurnSnapshot;");
global::robocode.control.events.TurnEndedEvent.j4n__ctorTurnEndedEvent1 = @__env.GetMethodID(global::robocode.control.events.TurnEndedEvent.staticClass, "<init>", "(Lrobocode/control/snapshot/ITurnSnapshot;)V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.nio.BufferOverflowException.staticClass = @__class;
global::java.nio.BufferOverflowException.j4n__ctorBufferOverflowException0 = @__env.GetMethodID(global::java.nio.BufferOverflowException.staticClass, "<init>", "()V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.lang.@__Cloneable.staticClass = @__class;
}
public ClassConfiguration(java.lang.Class hostClass, java.lang.Class[] domClasses, bool jsObject)
: this(new com.gargoylesoftware.htmlunit.javascript.configuration.ClassConfiguration(hostClass, domClasses, jsObject))
{
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::PaymentGateway.@__BatchRecord.staticClass = @__class;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.definition.@__KnowledgeDefinition.staticClass = @__class;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::net.sf.robocode.core.ContainerBase.staticClass = @__class;
global::net.sf.robocode.core.ContainerBase.j4n_getComponent0 = @__env.GetStaticMethodID(global::net.sf.robocode.core.ContainerBase.staticClass, "getComponent", "(Ljava/lang/Class;)Ljava/lang/Object;");
global::net.sf.robocode.core.ContainerBase.j4n_instance1 = @__env.GetStaticFieldID(global::net.sf.robocode.core.ContainerBase.staticClass, "instance", "Lnet/sf/robocode/core/ContainerBase;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.io.@__Closeable.staticClass = @__class;
global::java.io.@__Closeable._close0 = @__env.GetMethodID(global::java.io.@__Closeable.staticClass, "close", "()V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::ClassLib.@__CommunicationManager.staticClass = @__class;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.lang.NoClassDefFoundError.staticClass = @__class;
global::java.lang.NoClassDefFoundError.@__ctorNoClassDefFoundError0 = @__env.GetMethodID(global::java.lang.NoClassDefFoundError.staticClass, "<init>", "(Ljava/lang/String;)V");
global::java.lang.NoClassDefFoundError.@__ctorNoClassDefFoundError1 = @__env.GetMethodID(global::java.lang.NoClassDefFoundError.staticClass, "<init>", "()V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::org.drools.runtime.@__CommandExecutor.staticClass = @__class;
global::org.drools.runtime.@__CommandExecutor._execute0 = @__env.GetMethodID(global::org.drools.runtime.@__CommandExecutor.staticClass, "execute", "(Lorg/drools/command/Command;)Ljava/lang/Object;");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::System.IO.@__Stream.staticClass = @__class;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.control.events.BattleErrorEvent.staticClass = @__class;
global::robocode.control.events.BattleErrorEvent.j4n_getError0 = @__env.GetMethodID(global::robocode.control.events.BattleErrorEvent.staticClass, "getError", "()Ljava/lang/String;");
global::robocode.control.events.BattleErrorEvent.j4n__ctorBattleErrorEvent1 = @__env.GetMethodID(global::robocode.control.events.BattleErrorEvent.staticClass, "<init>", "(Ljava/lang/String;)V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.control.events.TurnStartedEvent.staticClass = @__class;
global::robocode.control.events.TurnStartedEvent.j4n__ctorTurnStartedEvent0 = @__env.GetMethodID(global::robocode.control.events.TurnStartedEvent.staticClass, "<init>", "()V");
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::ClassLib.@__TopicsConfiguration.staticClass = @__class;
}
private static string typeToName(Class type)
{
if (type.IsArray && type.HasElementType)
{
return typeToSpec(type.GetElementType()) + "[]";
}
lock (ShortNameType)
{
string shortName;
if (TypeShortName.TryGetValue(type, out shortName))
{
return shortName;
}
string typeName = type.Name;
Type otherType;
if (ShortNameType.TryGetValue(type.Name, out otherType))
{
if (type == otherType)
{
return typeName;
}
return type.FullName;
}
ShortNameType[typeName] = type;
TypeShortName[type] = typeName;
return typeName;
}
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::robocode.control.snapshot.@__IDebugProperty.staticClass = @__class;
global::robocode.control.snapshot.@__IDebugProperty.j4n_getValue0 = @__env.GetMethodID(global::robocode.control.snapshot.@__IDebugProperty.staticClass, "getValue", "()Ljava/lang/String;");
global::robocode.control.snapshot.@__IDebugProperty.j4n_getKey1 = @__env.GetMethodID(global::robocode.control.snapshot.@__IDebugProperty.staticClass, "getKey", "()Ljava/lang/String;");
}
public static object newAnnotationInvocationHandler(jlClass type, object memberValues)
{
#if FIRST_PASS
return null;
#else
return new global::sun.reflect.annotation.AnnotationInvocationHandler(type, (global::java.util.Map)memberValues);
#endif
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::System.Reflection.@__FieldInfo.staticClass = @__class;
}
public static Type getInstanceTypeFromClass(jlClass clazz)
{
TypeWrapper wrapper = TypeWrapper.FromClass(clazz);
if(wrapper.IsRemapped && wrapper.IsFinal)
{
return wrapper.TypeAsTBD;
}
return wrapper.TypeAsBaseType;
}
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class)
{
global::java.lang.@__Iterable.staticClass = @__class;
global::java.lang.@__Iterable.j4n_iterator0 = @__env.GetMethodID(global::java.lang.@__Iterable.staticClass, "iterator", "()Ljava/util/Iterator;");
}
private java.lang.Class[] GetExceptions()
{
string[] classes = declaredExceptions;
Type[] types = Type.EmptyTypes;
if (classes == null)
{
// NOTE if method is a MethodBuilder, GetCustomAttributes doesn't work (and if
// the method had any declared exceptions, the declaredExceptions field would have
// been set)
if (method != null && !(method is MethodBuilder))
{
ThrowsAttribute attr = AttributeHelper.GetThrows(method);
if (attr != null)
{
classes = attr.classes;
types = attr.types;
}
}
}
if (classes != null)
{
java.lang.Class[] array = new java.lang.Class[classes.Length];
for (int i = 0; i < classes.Length; i++)
{
array[i] = this.DeclaringType.GetClassLoader().LoadClassByDottedName(classes[i]).ClassObject;
}
return array;
}
else
{
java.lang.Class[] array = new java.lang.Class[types.Length];
for (int i = 0; i < types.Length; i++)
{
array[i] = types[i];
}
return array;
}
}
public void Initialize(bool tryUpdateCoreJar = true, string coreJarRemoteBaseUrl = "http://www.mkhx.cc/resources/lib/corejar", string javaHome = null)
{
OnLogging(TraceLevel.Info, string.Format("Initializing GameLauncherFacade...tryUpdateCoreJar = {0}", tryUpdateCoreJar));
var assemblyDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var jarPath = Path.Combine(assemblyDir, coreJarFileName);
OnLogging(TraceLevel.Info, string.Format("Local CoreJarPath = {0}", jarPath));
bool jarExists = File.Exists(jarPath);
OnLogging(TraceLevel.Info, string.Format("Local CoreJarExists = {0}", jarExists));
var verPath = Path.Combine(assemblyDir, coreJarVersionFileName);
OnLogging(TraceLevel.Info, string.Format("Local CoreJarVersionFilePath = {0}", verPath));
var verExists = File.Exists(verPath);
OnLogging(TraceLevel.Info, string.Format("Local CoreJarVersionFileExists = {0}", verExists));
long existingVer = 0;
if (jarExists && verExists)
{
var existingVerText = File.ReadAllText(verPath);
var parseSuccess = long.TryParse(existingVerText, out existingVer);
if (parseSuccess)
{
OnLogging(TraceLevel.Info, string.Format("Successfully get local core jar version: {0}", existingVer));
}
else
{
OnLogging(TraceLevel.Warning, string.Format("Failed to get local core jar version! Invalid version text: {0}", existingVerText));
}
}
if (tryUpdateCoreJar || !jarExists)
{
OnLogging(TraceLevel.Info, "Trying to update local core jar with latest one on server.");
using (WebClient client = new WebClient())
{
try
{
var remoteVerUrl = coreJarRemoteBaseUrl + "/" + coreJarVersionFileName;
long latestVer = long.MaxValue;
try
{
OnLogging(TraceLevel.Info, string.Format("Downloading version file from {0}...", remoteVerUrl));
var latestVerText = client.DownloadString(remoteVerUrl);
OnLogging(TraceLevel.Info, "Done!");
if (!long.TryParse(latestVerText, out latestVer))
{
OnLogging(TraceLevel.Warning, string.Format("Server returns an invalid core jar file version: {0}. Force update...", latestVerText));
}
}
catch (Exception e)
{
OnLogging(TraceLevel.Error, string.Format("Failed to get remote core jar version: {0}", e));
OnLogging(TraceLevel.Info, "Force update!");
}
OnLogging(TraceLevel.Info, string.Format("Remote core jar version: {0}", latestVer));
if (!jarExists || existingVer < latestVer)
{
OnLogging(TraceLevel.Info, "Trying to replace local core jar with remote one...");
var remoteCoreJarUrl = coreJarRemoteBaseUrl + "/" + coreJarFileName;
OnLogging(TraceLevel.Info, string.Format("Downloading core jar file from {0}...", remoteCoreJarUrl));
client.DownloadFile(remoteCoreJarUrl, jarPath);
OnLogging(TraceLevel.Info, "Done!");
var remoteCoreJarVerFileUrl = coreJarRemoteBaseUrl + "/" + coreJarVersionFileName;
OnLogging(TraceLevel.Info, string.Format("Downloading core jar version file from {0}...", remoteCoreJarVerFileUrl));
client.DownloadFile(remoteCoreJarVerFileUrl, verPath);
OnLogging(TraceLevel.Info, "Done!");
}
else
{
OnLogging(TraceLevel.Info, "Local core jar file is already update-to-date.");
}
}
catch (Exception e)
{
OnLogging(TraceLevel.Error, "Failed to update local core jar with remote one due to error: " + e.ToString());
if (!jarExists)
{
throw new InvalidOperationException("Core jar file does not exists either on server or at local.", e);
}
}
}
}
OnLogging(TraceLevel.Info, "Initializing JVM...");
var setup = new net.sf.jni4net.BridgeSetup();
if (!string.IsNullOrEmpty(javaHome))
{
setup.JavaHome = javaHome;
}
setup.AddClassPath(jarPath);
this.jvm = net.sf.jni4net.Bridge.CreateJVM(setup);
this.facadeClass = this.jvm.FindClass("cfvbaibai/cardfantasy/game/launcher/GameLauncherFacade");
OnLogging(TraceLevel.Info, "JVM initialized!");
OnLogging(TraceLevel.Info, "Facade is fully initialized.");
}
