/// <summary> /// Create the current type as class definition. /// </summary> protected override void CreateClassDefinition(DexTargetPackage targetPackage, ClassDefinition parent, TypeDefinition parentType, XModel.XTypeDefinition parentXType) { base.CreateClassDefinition(targetPackage, parent, parentType, parentXType); Class.IsFinal = true; //Class.IsAbstract = true;// Android 6.x verifier does not allow 'final abstract' a.k.a. static classes. Class.IsSynthetic = true; }
/// <summary> /// Create the name of the class. /// </summary> protected override string CreateClassName(XModel.XTypeDefinition xType) { return(ClassName); }
/// <summary> /// Create the current type as class definition. /// </summary> protected override void CreateClassDefinition(DexTargetPackage targetPackage, ClassDefinition parent, TypeDefinition parentType, XModel.XTypeDefinition parentXType) { base.CreateClassDefinition(targetPackage, parent, parentType, parentXType); Class.IsFinal = false; Class.IsAbstract = true; Class.IsSynthetic = true; }
/// <summary> /// Create an annotation interface. /// </summary> internal static AttributeAnnotationInterface Create( ISourceLocation sequencePoint, AssemblyCompiler compiler, DexTargetPackage targetPackage, TypeDefinition attributeType, ClassDefinition attributeClass) { // Create class ClassDefinition @interface = new ClassDefinition(); @interface.Name = CreateAnnotationTypeName(attributeClass); @interface.Namespace = attributeClass.Namespace; @interface.AccessFlags = AccessFlags.Public | AccessFlags.Abstract | AccessFlags.Interface | AccessFlags.Annotation; @interface.Owner = attributeClass; attributeClass.InnerClasses.Add(@interface); // Set super class @interface.SuperClass = new ClassReference("java/lang/Object"); // Implement Dot42.Internal.IAttribute @interface.Interfaces.Add(new ClassReference("java/lang/annotation/Annotation")); // Prepare result AttributeAnnotationInterface result = new AttributeAnnotationInterface(@interface); // Add methods from IAttribute XModel.XTypeDefinition baseIntfType = compiler.GetDot42InternalType("IAttribute").Resolve(); foreach (XModel.XMethodDefinition imethod in baseIntfType.Methods) { if (imethod.Parameters.Count > 0) { throw new CompilerException(string.Format("Invalid IAttribute method {0}", imethod)); } string methodName = NameConverter.GetConvertedName(imethod); TypeReference dfieldType = imethod.ReturnType.GetReference(targetPackage); MethodDefinition method = new MethodDefinition(@interface, methodName, new Prototype(dfieldType)); method.AccessFlags = AccessFlags.Public | AccessFlags.Abstract; @interface.Methods.Add(method); } // Add field mapping foreach (var field in attributeType.Fields.Where(x => x.IsReachable && x.IsPublic)) { string methodName = CreateGetMethodName(NameConverter.GetConvertedName(field), result); TypeReference dfieldType = field.FieldType.GetReference(targetPackage, compiler.Module); MethodDefinition method = new MethodDefinition(@interface, methodName, new Prototype(dfieldType)); method.AccessFlags = AccessFlags.Public | AccessFlags.Abstract; result.FieldToGetMethodMap.Add(field, method); @interface.Methods.Add(method); } // Add property mapping foreach (var property in attributeType.Properties.Where(x => x.IsReachable && (x.SetMethod != null) && (x.SetMethod.IsPublic) && x.SetMethod.IsReachable)) { string methodName = CreateGetMethodName(NameConverter.GetConvertedName(property), result); TypeReference dpropType = property.PropertyType.GetReference(targetPackage, compiler.Module); MethodDefinition method = new MethodDefinition(@interface, methodName, new Prototype(dpropType)); method.AccessFlags = AccessFlags.Public | AccessFlags.Abstract; result.PropertyToGetMethodMap.Add(property, method); @interface.Methods.Add(method); } // Add ctor mapping var argIndex = 0; foreach (var ctor in attributeType.Methods.Where(x => (x.Name == ".ctor") && x.IsReachable)) { // Add methods for the ctor arguments List <MethodDefinition> paramGetMethods = new List <MethodDefinition>(); foreach (ParameterDefinition p in ctor.Parameters) { string methodName = CreateGetMethodName("c" + argIndex++, result); TypeReference dparamType = p.ParameterType.GetReference(targetPackage, compiler.Module); MethodDefinition method = new MethodDefinition(@interface, methodName, new Prototype(dparamType)); method.AccessFlags = AccessFlags.Public | AccessFlags.Abstract; @interface.Methods.Add(method); paramGetMethods.Add(method); } // Add a builder method MethodDefinition buildMethod = CreateBuildMethod(sequencePoint, ctor, paramGetMethods, compiler, targetPackage, attributeClass, result); result.CtorMap.Add(ctor, new AttributeCtorMapping(buildMethod, paramGetMethods)); } // Create default values annotation Annotation defAnnotation = CreateDefaultAnnotation(result); result.AnnotationInterfaceClass.Annotations.Add(defAnnotation); return(result); }