private static IRemoteTechAPIv1 InitializeAPI()
{
SafeHouse.Logger.Log(string.Format("Looking for RemoteTech"));
var loadedAssembly = AssemblyLoader.loadedAssemblies.FirstOrDefault(a => a.assembly.GetName().Name.Equals(REMOTE_TECH_ASSEMBLY));
if (loadedAssembly == null)
{
return(null);
}
SafeHouse.Logger.Log(string.Format("Found RemoteTech! Version: {0}.{1}", loadedAssembly.versionMajor, loadedAssembly.versionMinor));
var type = ReflectUtil.GetLoadedTypes(loadedAssembly.assembly).FirstOrDefault(t => t.FullName.Equals(REMOTE_TECH_API)) ??
ReflectUtil.GetLoadedTypes(loadedAssembly.assembly).FirstOrDefault(t => t.FullName.Equals(ALT_REMOTE_TECH_API));
if (type == null)
{
return(null);
}
SafeHouse.Logger.Log(string.Format("Found API! {0} ", type.Name));
var methods = type.GetMethods();
var api = new RemoteTechAPI();
try
{
foreach (var property in api.GetType().GetProperties())
{
var method = methods.FirstOrDefault(m =>
{
if (m.Name.Equals(property.Name))
{
SafeHouse.Logger.Log(string.Format("Found Endpoint: {0}", m.Name));
return(true);
}
return(false);
});
if (method == null)
{
throw new ArgumentNullException(property.Name);
}
var del = Delegate.CreateDelegate(property.PropertyType, type, method.Name);
property.SetValue(api, del, null);
}
}
catch (Exception e)
{
SafeHouse.Logger.Log("Error creating RemoteTech interface: " + e);
return(null);
}
SafeHouse.Logger.Log("RemoteTech interface successfully created.");
return(api);
}
/// <summary>
/// Ensure all classes implementing IDumper have the required static method in
/// them, which is something the compiler cannot enforce itself because an Interface
/// can't contain static things.
/// </summary>
/// Since interfaces don't enforce static things, this enforcement
/// is being done via this Reflection check upon loading that will make nag messages
/// if the CreateFromDump is missing on one of the classes.
/// Note, if we ever need this check elsewhere for another "static" thing in an interface,
/// It should be possible to make this more generic and make a library method here that
/// takes any interface name and any method name and checks to see if it exists.
public static void CheckIDumperStatics()
{
if (staticsAlreadyChecked)
{
return;
}
StringBuilder message = new StringBuilder(1000);
Type dumperInterface = typeof(IDumper);
// It's ugly to be checking ALL KSP mods here, but just in case someone
// extends kOS in another mod, it's not safe to check ONLY kOS.dll and kOS.Safe.dll:
Assembly[] allKSPAssemblies = AppDomain.CurrentDomain.GetAssemblies();
// All the classes in which the class is derived from IDumper, and instances of the class are
// actually constructable because it isn't Abstract:
IEnumerable <Type> iDumperClasses = allKSPAssemblies.SelectMany(a => ReflectUtil.GetLoadedTypes(a)).Where(
b => dumperInterface.IsAssignableFrom(b) && b.IsClass && !b.IsAbstract);
List <string> offendingClasses = new List <string>();
Type[] paramSignature = new Type[] { typeof(SafeSharedObjects), typeof(Dump) };
foreach (Type t in iDumperClasses)
{
if (t.GetMethod("CreateFromDump", BindingFlags.Public | BindingFlags.Static, null, paramSignature, null) == null)
{
offendingClasses.Add(t.FullName);
}
}
if (offendingClasses.Count() > 0)
{
message.Append(
"kOS DEV TEAM ERROR.\n " +
" This is a kOS source problem that the compiler\n" +
" cannot check for because of limitations in C#.\n" +
" (So we check it at runtime and give this error\n" +
" if it's detected.)\n" +
" \n" +
" The following class(es) implement IDumper, but\n" +
" lack the required CreateFromDump() static method\n" +
" that we need all IDumper's to have:\n" +
" ");
message.Append(string.Join(", ", offendingClasses.ToArray()));
Debug.AddNagMessage(Debug.NagType.NAGFOREVER, message.ToString());
}
staticsAlreadyChecked = true;
}