Java 类com.badlogic.gdx.utils.reflect.Field 实例源码

private OrderedMap<String, Field> getStaticFields(Class type) {
    if (staticFields.containsKey(type))
        return staticFields.get(type);
    Field[] fields = ClassReflection.getDeclaredFields(type);
    OrderedMap<String, Field> nameToField = new OrderedMap(fields.length);
    for (Field field : fields) {
        if (!field.isStatic())
            continue;
        if (!field.isAccessible()) {
            try {
                field.setAccessible(true);
            } catch (AccessControlException ex) {
                continue;
            }
        }

        nameToField.put(field.getName(), field);
    }
    staticFields.put(type, nameToField);
    return nameToField;
}

private Metadata findMetadata (Class<?> clazz) {
    Metadata metadata = metadataCache.get(clazz);
    if (metadata == null) {
        Annotation tca = ClassReflection.getAnnotation(clazz, TaskConstraint.class);
        if (tca != null) {
            TaskConstraint taskConstraint = tca.getAnnotation(TaskConstraint.class);
            ObjectMap<String, AttrInfo> taskAttributes = new ObjectMap<String, AttrInfo>();
            Field[] fields = ClassReflection.getFields(clazz);
            for (Field f : fields) {
                Annotation a = f.getDeclaredAnnotation(TaskAttribute.class);
                if (a != null) {
                    AttrInfo ai = new AttrInfo(f.getName(), a.getAnnotation(TaskAttribute.class));
                    taskAttributes.put(ai.name, ai);
                }
            }
            metadata = new Metadata(taskConstraint.minChildren(), taskConstraint.maxChildren(), taskAttributes);
            metadataCache.put(clazz, metadata);
        }
    }
    return metadata;
}

/** Does the actual processing of found fields.
 *
 * @param component owner of the fields.
 * @param fields present in one of superclasses of the component.
 * @param context used to resolve dependencies.
 * @param contextDestroyer used to register destruction callbacks. */
@SuppressWarnings({ "rawtypes", "unchecked" }) // Using correct types, but wildcards fail to see that.
private void processFields(final Object component, final Field[] fields, final Context context,
        final ContextDestroyer contextDestroyer) {
    for (final Field field : fields) {
        final com.badlogic.gdx.utils.reflect.Annotation[] annotations = getAnnotations(field);
        if (annotations == null || annotations.length == 0) {
            continue;
        }
        for (final com.badlogic.gdx.utils.reflect.Annotation annotation : annotations) {
            if (fieldProcessors.containsKey(annotation.getAnnotationType())) {
                for (final AnnotationProcessor processor : fieldProcessors.get(annotation.getAnnotationType())) {
                    processor.processField(field, annotation.getAnnotation(annotation.getAnnotationType()),
                            component, context, this, contextDestroyer);
                }
            }
        }
    }
}

@Override
public void processField(final Field field, final LmlMacro annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object macroData = Reflection.getFieldValue(field, component);
        final LmlParser parser = interfaceService.get().getParser();
        final FileType fileType = annotation.fileType();
        if (macroData instanceof String) {
            parser.parseTemplate(Gdx.files.getFileHandle((String) macroData, fileType));
        } else if (macroData instanceof String[]) {
            for (final String macroPath : (String[]) macroData) {
                parser.parseTemplate(Gdx.files.getFileHandle(macroPath, fileType));
            }
        } else {
            throw new GdxRuntimeException("Invalid type of LML macro definition in component: " + component
                    + ". String or String[] expected, received: " + macroData + ".");
        }
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException(
                "Unable to extract macro paths from field: " + field + " of component: " + component + ".",
                exception);
    }
}

/** Does the actual processing of found fields.
 *
 * @param component owner of the fields.
 * @param fields present in one of superclasses of the component.
 * @param context used to resolve dependencies.
 * @param contextDestroyer used to register destruction callbacks. */
@SuppressWarnings({ "rawtypes", "unchecked" }) // Using correct types, but wildcards fail to see that.
private void processFields(final Object component, final Field[] fields, final Context context,
        final ContextDestroyer contextDestroyer) {
    for (final Field field : fields) {
        final com.badlogic.gdx.utils.reflect.Annotation[] annotations = getAnnotations(field);
        if (annotations == null || annotations.length == 0) {
            continue;
        }
        for (final com.badlogic.gdx.utils.reflect.Annotation annotation : annotations) {
            if (fieldProcessors.containsKey(annotation.getAnnotationType())) {
                for (final AnnotationProcessor processor : fieldProcessors.get(annotation.getAnnotationType())) {
                    processor.processField(field, annotation.getAnnotation(annotation.getAnnotationType()),
                            component, context, this, contextDestroyer);
                }
            }
        }
    }
}

private void handleLazyAssetInjection(final Object component, final Field field, final Asset assetData) {
    if (Annotations.isNotVoid(assetData.lazyCollection())) {
        handleLazyAssetCollectionInjection(component, field, assetData);
        return;
    } else if (assetData.value().length != 1) {
        throw new GdxRuntimeException(
                "Lazy wrapper can contain only one asset if lazy collection type is not provided. Found multiple assets in field: "
                        + field + " of component: " + component);
    }
    final String assetPath = assetData.value()[0];
    if (!assetData.loadOnDemand()) {
        load(assetPath, assetData.type());
    }
    try {
        Reflection.setFieldValue(field, component,
                Lazy.providedBy(new AssetProvider(this, assetPath, assetData.type(), assetData.loadOnDemand())));
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException("Unable to inject lazy asset.", exception);
    }
}

@Override
public void processField(final Field field, final LmlParserSyntax annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object syntax = Reflection.getFieldValue(field, component);
        if (syntax instanceof LmlSyntax) {
            interfaceService.getParser().setSyntax((LmlSyntax) syntax);
        } else {
            throw new ContextInitiationException(
                    "LmlParserSyntax-annotated fields need to contain an instance of LmlSyntax. Found: " + syntax
                            + " in field: " + field + " of component: " + component);
        }
    } catch (final ReflectionException exception) {
        throw new ContextInitiationException(
                "Unable to extract LML syntax from field: " + field + " of component: " + component, exception);
    }
}

private void handleLazyAssetInjection(final Object component, final Field field, final Asset assetData) {
    if (Annotations.isNotVoid(assetData.lazyCollection())) {
        handleLazyAssetCollectionInjection(component, field, assetData);
        return;
    } else if (assetData.value().length != 1) {
        throw new GdxRuntimeException(
                "Lazy wrapper can contain only one asset if lazy collection type is not provided. Found multiple assets in field: "
                        + field + " of component: " + component);
    }
    final String assetPath = assetData.value()[0];
    if (!assetData.loadOnDemand()) {
        load(assetPath, assetData.type());
    }
    try {
        Reflection.setFieldValue(field, component,
                Lazy.providedBy(new AssetProvider(this, assetPath, assetData.type(), assetData.loadOnDemand())));
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException("Unable to inject lazy asset.", exception);
    }
}

@Override
public void processField(final Field field, final AvailableLocales annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object locales = Reflection.getFieldValue(field, component);
        if (locales instanceof String[]) {
            final String[] availableLocales = (String[]) locales;
            final LmlParser parser = interfaceService.getParser();

            parser.getData().addArgument(annotation.viewArgumentName(), availableLocales);
            for (final String locale : availableLocales) {
                parser.getData().addActorConsumer(annotation.localeChangeMethodPrefix() + locale,
                        new LocaleChangingAction(localeService, LocaleService.toLocale(locale)));
            }
            return;
        }
        throw new GdxRuntimeException("Invalid field annotated with @AvailableLocales in component " + component
                + ". Expected String[], received: " + locales + ".");
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException(
                "Unable to read available locales from field: " + field + " of component: " + component + ".",
                exception);
    }
}

@Override
public void processField(final Field field, final Asset annotation, final Object component, final Context context,
        final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    validateAssetData(component, field, annotation);
    if (field.getType().equals(Lazy.class)) {
        handleLazyAssetInjection(component, field, annotation);
    } else if (field.getType().equals(Array.class)) {
        handleArrayInjection(component, field, annotation);
    } else if (field.getType().equals(ObjectSet.class)) {
        handleSetInjection(component, field, annotation);
    } else if (field.getType().equals(ObjectMap.class)) {
        handleMapInjection(component, field, annotation);
    } else {
        handleRegularAssetInjection(component, field, annotation);
    }
}

@Override
public void processField(final Field field, final AvailableLocales annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object locales = Reflection.getFieldValue(field, component);
        if (locales instanceof String[]) {
            final String[] availableLocales = (String[]) locales;
            final LmlParser parser = interfaceService.getParser();

            parser.getData().addArgument(annotation.viewArgumentName(), availableLocales);
            for (final String locale : availableLocales) {
                parser.getData().addActorConsumer(annotation.localeChangeMethodPrefix() + locale,
                        new LocaleChangingAction(localeService, LocaleService.toLocale(locale)));
            }
            return;
        }
        throw new GdxRuntimeException("Invalid field annotated with @AvailableLocales in component " + component
                + ". Expected String[], received: " + locales + ".");
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException(
                "Unable to read available locales from field: " + field + " of component: " + component + ".",
                exception);
    }
}

protected <View> void processLmlActorAnnotation(final View view, final Field field) {
    if (Reflection.isAnnotationPresent(field, LmlActor.class)) {
        final LmlActor actorData = Reflection.getAnnotation(field, LmlActor.class);
        String[] actorIds = actorData.value();
        if (actorIds.length == 0) {
            actorIds = new String[] { field.getName() };
        }
        if (Reflection.isExtending(field.getType(), Array.class)) {
            injectArrayOfActors(view, field, actorIds);
        } else if (Reflection.isExtending(field.getType(), ObjectSet.class)) {
            injectSetOfActors(view, field, actorIds);
        } else if (Reflection.isExtending(field.getType(), ObjectMap.class)) {
            injectMapOfActors(view, field, actorIds);
        } else {
            injectSingleActor(view, field, actorIds);
        }
    }
}

/** @param actionContainer action container that might contain the referenced method.
 * @param actionId name of the requested action.
 * @param forActor will be used as potential action argument.
 * @return actor consumer constructed with container's method (or field) or null if action not found. */
protected ActorConsumer<?, ?> extractActionFromContainer(final ActionContainerWrapper actionContainer,
        final String actionId, final Object forActor) {
    Method method = actionContainer.getNamedMethod(actionId);
    if (method == null && Lml.EXTRACT_UNANNOTATED_METHODS) {
        method = findUnnamedMethod(actionContainer, actionId, forActor);
    }
    if (method != null) {
        return new MethodActorConsumer(method, actionContainer.getActionContainer());
    } else if (Lml.EXTRACT_FIELDS_AS_METHODS) {
        Field field = actionContainer.getNamedField(actionId);
        if (field == null && Lml.EXTRACT_UNANNOTATED_METHODS) {
            field = actionContainer.getField(actionId);
        }
        if (field != null) {
            return new FieldActorConsumer(field, actionContainer.getActionContainer());
        }
    }
    return null;
}

private void mapClassFields(final Class<?> containerClass) {
    if (!Lml.EXTRACT_FIELDS_AS_METHODS) {
        return;
    }
    for (final Field field : ClassReflection.getDeclaredFields(containerClass)) {
        final LmlAction actionData = Reflection.getAnnotation(field, LmlAction.class);
        if (actionData != null) {
            final String[] ids = actionData.value();
            if (ids.length > 0) {
                for (final String actionId : ids) {
                    annotatedFields.put(actionId, field);
                }
            } else {
                annotatedFields.put(field.getName(), field);
            }
        }
    }
}

@Override
public void processField(final Field field, final LmlMacro annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object macroData = Reflection.getFieldValue(field, component);
        final FileType fileType = annotation.fileType();
        if (macroData instanceof String) {
            macros.add(Gdx.files.getFileHandle((String) macroData, fileType));
        } else if (macroData instanceof String[]) {
            for (final String macroPath : (String[]) macroData) {
                macros.add(Gdx.files.getFileHandle(macroPath, fileType));
            }
        } else {
            throw new GdxRuntimeException("Invalid type of LML macro definition in component: " + component
                    + ". String or String[] expected, received: " + macroData + ".");
        }
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException(
                "Unable to extract macro paths from field: " + field + " of component: " + component + ".",
                exception);
    }
}

/** @param field reflected field data.
 * @param component owner of the field.
 * @return true if the field is empty, accepted by the modifier filter, does not match modifier signature, not
 *         primitive and - if strings are ignored - not a string.
 * @throws Exception due to reflection issues. */
protected boolean isInjectable(final Field field, final Object component) throws Exception {
    try {
        if (field.isSynthetic() || field.getType().isPrimitive()
                || isIgnoreStrings() && field.getType() == String.class) {
            return false;
        }
    } catch (final Exception exception) {
        Exceptions.ignore(exception); // GWT compatibility.
        Gdx.app.debug("UEDI", "Unable to access field of component: " + component, exception);
        return false;
    }
    final int modifier = Modifier.getModifiers(field);
    if ((modifier & getFieldsIgnoreFilter()) != 0 || modifier == getFieldsIgnoreSignature()) {
        return false;
    }
    field.setAccessible(true);
    return field.get(component) == null;
}

@Override
public void processField(final Field field, final LmlParserSyntax annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object syntax = Reflection.getFieldValue(field, component);
        if (syntax instanceof LmlSyntax) {
            interfaceService.getParser().setSyntax((LmlSyntax) syntax);
        } else {
            throw new ContextInitiationException(
                    "LmlParserSyntax-annotated fields need to contain an instance of LmlSyntax. Found: " + syntax
                            + " in field: " + field + " of component: " + component);
        }
    } catch (final ReflectionException exception) {
        throw new ContextInitiationException(
                "Unable to extract LML syntax from field: " + field + " of component: " + component, exception);
    }
}

private void handleRegularAssetInjection(final Object component, final Field field, final Asset assetData) {
    if (assetData.value().length != 1) {
        throw new GdxRuntimeException(
                "Regular fields can store only 1 asset. If the field is a collection, its type is not currently supported: only LibGDX Array, ObjectSet and ObjectMap are permitted. Regular arrays will not be supported. Found multiple assets in field: "
                        + field + " of component: " + component);
    }
    final String assetPath = assetData.value()[0];
    if (assetData.loadOnDemand()) {
        // Loaded immediately.
        @SuppressWarnings("unchecked") final Object asset = finishLoading(assetPath, field.getType());
        try {
            Reflection.setFieldValue(field, component, asset);
        } catch (final ReflectionException exception) {
            throw new GdxRuntimeException("Unable to inject asset loaded on demand.", exception);
        }
    } else {
        load(assetPath, field.getType());
        // Scheduled to be loaded, delayed injection.
        assetInjections.add(new StandardAssetInjection(field, assetPath, component));
    }
}

private static int getPixmapColor (Pixmap pixmap){
    int color = 0;
    try {
        Field colorField = ClassReflection.getDeclaredField(Pixmap.class, "color");
        colorField.setAccessible(true);
        color = (Integer)colorField.get(pixmap);
    } catch (ReflectionException e) {
        Log.error("Color field of pixmap could not be read. Using transparent black.", e);
    }
    return color;
}

public <T> T getStaticFieldValue(Class<T> type, String fieldName) {
    OrderedMap<String, Field> fields = getStaticFields(type);
    Field field = fields.get(fieldName, null);
    Throwable throwable = null;
    if (field != null) {
        try {
            return (T) field.get(null);
        } catch (ReflectionException e) {
            throwable = e;
        }
    }
    error(String.format("Could not retrieve static field value %s from class %s.", fieldName, type.getName()), throwable);
    return null;
}

@Override
public synchronized boolean update () {
    boolean done = super.update();
    if (done) {
        // assign references to Asset fields of queuedContainers
        for (Object assetContainer : queuedContainers) {
            ObjectMap<Field, AssetDescriptor<?>> fieldsToAssets = containersFieldsToAssets.get(assetContainer);
            for (ObjectMap.Entry<Field, AssetDescriptor<?>> fieldEntry : fieldsToAssets) {
                Field field = fieldEntry.key;
                makeAccessible(field);
                try {
                    field.set(assetContainer, get(fieldEntry.value));
                } catch (ReflectionException e) {
                    throw new GdxRuntimeException("Failed to assign loaded asset " + field.getName(), e);
                }
            }
            ObjectMap<Object[], AssetDescriptor<?>[]> fieldsToAssetArrays = containersFieldsToAssetArrays.get(assetContainer);
            for (ObjectMap.Entry<Object[], AssetDescriptor<?>[]> arrayEntry : fieldsToAssetArrays) {
                Object[] destinationArray = arrayEntry.key;
                AssetDescriptor<?>[] descriptors = arrayEntry.value;
                for (int i = 0; i < descriptors.length; i++) {
                    destinationArray[i] = get(descriptors[i]);
                }
            }

            if (assetContainer instanceof AssetContainer)
                ((AssetContainer) assetContainer).onAssetsLoaded();
        }

        loadedContainers.addAll(queuedContainers);
        queuedContainers.clear();
    }
    return done;
}

private void makeAccessible (Field field) {
    if (!field.isAccessible()) {
        try {
            field.setAccessible(true);
        } catch (AccessControlException ex) {
            throw new GdxRuntimeException(String.format("Field %s cannot be made accessible", field.getName()));
        }
    }
}

/**
 * Check if exist a MapWayPointItemStyle for all CacheTypes and WayPointTypes
 */
@Override
public void runValidation() {

    checkCacheTypes();


    //Check changes of MapWayPointItemStyle.class
    Field[] fields = ClassReflection.getFields(MapWayPointItemStyle.class);
    String classChanged = "";
    if (fields.length > 3) {
        classChanged = "MapWayPointItemStyle is changed, maybe you must add new Validation " +
                "on de.longri.cachebox3.develop.tools.skin_editor.validation.Validate_MapWayPointItemStyle.java";
    }


    //set result
    if (missingBitmaps.length > 0 || missingSyles.length > 0) {
        errorMsg = "Missing Styles:\n\n" + missingSyles.toString() + "\n\nMissing Bitmaps:\n\n" + missingBitmaps.toString();
    }

    if (!classChanged.isEmpty()) {
        warnMsg = classChanged + "\n\n Wrong Sizes:\n\n" + wrongBitmapsSize.toString();
    } else if (wrongBitmapsSize.length > 0) {
        warnMsg = "Wrong Sizes:\n\n" + wrongBitmapsSize.toString();
    }


}

/**
 * Is font is already in use somewhere else?
 */
public boolean isFontInUse(BitmapFont font) {

    try {
        // Check if it is already in use somewhere!
        for (String widget : SkinEditorGame.widgets) {
            String widgetStyle = "com.badlogic.gdx.scenes.scene2d.ui." + widget + "$" + widget + "Style";
            Class<?> style = Class.forName(widgetStyle);
            ObjectMap<String, ?> styles = game.skinProject.getAll(style);
            Iterator<String> it = styles.keys().iterator();
            while (it.hasNext()) {
                Object item = styles.get((String) it.next());
                Field[] fields = ClassReflection.getFields(item.getClass());
                for (Field field : fields) {

                    if (field.getType() == BitmapFont.class) {

                        BitmapFont f = (BitmapFont) field.get(item);
                        if (font.equals(f)) {
                            return true;
                        }

                    }

                }

            }

        }
    } catch (Exception e) {
        e.printStackTrace();

    }

    return false;
}

public DrawablePickerDialog(final SkinEditorGame game, final Field field, int arrayIndex, boolean disableNinePatch, Stage stage) {
    super("Drawable Picker", game.skin);
    this.game = game;
    this.field = field;
    this.disableNinePatch = disableNinePatch;
    this.stage = stage;
    this.callSelectedSvg = false;
    this.arrayIndex = arrayIndex;
    initializeSelf();
}

@Override
protected <E> boolean attribute (DefaultBehaviorTreeReader<E> reader, String name, Object value) {
    StackedTask<E> stackedTask = reader.getCurrentTask();
    AttrInfo ai = stackedTask.metadata.attributes.get(name);
    if (ai == null) return false;
    boolean isNew = reader.encounteredAttributes.add(name);
    if (!isNew) throw reader.stackedTaskException(stackedTask, "attribute '" + name + "' specified more than once");
    Field attributeField = reader.getField(stackedTask.task.getClass(), ai.fieldName);
    reader.setField(attributeField, stackedTask.task, value);
    return true;
}

private Field getField (Class<?> clazz, String name) {
    try {
        return ClassReflection.getField(clazz, name);
    } catch (ReflectionException e) {
        throw new GdxRuntimeException(e);
    }
}

private void setField (Field field, Task<E> task, Object value) {
    field.setAccessible(true);
    Object valueObject = castValue(field, value);
    try {
        field.set(task, valueObject);
    } catch (ReflectionException e) {
        throw new GdxRuntimeException(e);
    }
}

public int getAxisAmount () {
    try {
        switch (Gdx.app.getType()) {
            case Android:
                Field androidAxes = ClassReflection
                    .getDeclaredField(ClassReflection.forName("com.badlogic.gdx.controllers.android.AndroidController"), "axes");
                androidAxes.setAccessible(true);
                return ((float[])androidAxes.get(gamePad)).length;
            case Desktop:
                Field desktopAxes = ClassReflection
                    .getDeclaredField(ClassReflection.forName("com.badlogic.gdx.controllers.lwjgl3.Lwjgl3Controller"), "axisState");
                desktopAxes.setAccessible(true);
                return ((float[])desktopAxes.get(gamePad)).length;
            case HeadlessDesktop:
                return 0;
            case WebGL:
                Field gwtAxes = ClassReflection
                    .getDeclaredField(ClassReflection.forName("com.badlogic.gdx.controllers.gwt.GwtController"), "axes");
                gwtAxes.setAccessible(true);
                return ((float[])gwtAxes.get(gamePad)).length;
            case iOS:
                return 0;
            default:
                break;
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return 0;
}

public int getButtonAmount () {
    try {
        switch (Gdx.app.getType()) {
            case Android:
                Field androidButtons = ClassReflection
                    .getDeclaredField(ClassReflection.forName("com.badlogic.gdx.controllers.android.AndroidController"), "buttons");
                androidButtons.setAccessible(true);
                return ((IntIntMap)androidButtons.get(gamePad)).size;
            case Desktop:
                Field desktopButtons = ClassReflection.getDeclaredField(
                    ClassReflection.forName("com.badlogic.gdx.controllers.lwjgl3.Lwjgl3Controller"), "buttonState");
                desktopButtons.setAccessible(true);
                return ((boolean[])desktopButtons.get(gamePad)).length;
            case HeadlessDesktop:
                return 0;
            case WebGL:
                Field gwtButtons = ClassReflection
                    .getDeclaredField(ClassReflection.forName("com.badlogic.gdx.controllers.gwt.GwtController"), "buttons");
                gwtButtons.setAccessible(true);
                return ((IntFloatMap)gwtButtons.get(gamePad)).size;
            case iOS:
                return 0;
            default:
                break;
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return 0;
}

/** Injects actors from group into target's fields annotated with {@link InjectActor} using reflection. */
public static void injectActorFields(Object target, Group group) {
    Class<?> handledClass = target.getClass();
    while (handledClass != null && !handledClass.equals(Object.class)) {
        for (final Field field : ClassReflection.getDeclaredFields(handledClass)) {
            if (field != null && field.isAnnotationPresent(InjectActor.class)) {
                try {
                    InjectActor annotation = field.getDeclaredAnnotation(InjectActor.class).getAnnotation(InjectActor.class);
                    String actorName = annotation.value();
                    if (actorName.length() == 0) {
                        actorName = field.getName();
                    }
                    Actor actor = group.findActor(actorName);
                    if (actor == null && actorName.equals(group.getName())) {
                        actor = group;
                    }
                    if (actor == null) {
                        Gdx.app.error(TAG_INJECT_FIELDS, "Can't find actor with name: " + actorName + " in group: " + group + " to inject into: " + target);
                    } else {
                        field.setAccessible(true);
                        field.set(target, actor);
                    }
                } catch (final ReflectionException exception) {
                    Gdx.app.error(TAG_INJECT_FIELDS, "Unable to set value into field: " + field + " of object: " + target, exception);
                }
            }
        }
        handledClass = handledClass.getSuperclass();
    }
}

@SuppressWarnings("static-access")
@Before
public void setup() {

    Gdx.app = Mockito.mock(HeadlessApplication.class);

    when(Gdx.app.getPreferences(anyString())).thenReturn(new PreferencesStub());

    config = new TwitterConfig();

    PowerMockito.mockStatic(ClassReflection.class);
    classReflectionMock = Mockito.mock(ClassReflection.class);

    PowerMockito.mockStatic(Field.class);
    fieldMock = Mockito.mock(Field.class);

    PowerMockito.mockStatic(Constructor.class);
    constructorMock = Mockito.mock(Constructor.class);

    PowerMockito.mockStatic(Method.class);
    methodMock = Mockito.mock(Method.class);

    activityStub = new ActivityStub();
    twitterAPIStub = new TwitterAPIStub(config);
    gdxStub = new GdxStub();
    supportFragmentStub = new SupportFragmentStub();
    fragmentStub = new FragmentStub();
    gdxLifecycleListenerStub = new GdxLifecycleListenerStub();

    try {
        Mockito.when(classReflectionMock.forName("com.badlogic.gdx.Gdx")).thenReturn(gdxStub.getClass());
        Mockito.when(classReflectionMock.getField(gdxStub.getClass(), "app")).thenReturn(fieldMock);
        Mockito.when(fieldMock.get(null)).thenReturn(Gdx.app);

    } catch (ReflectionException e) {
    }
}

@Override
public void processField(final Field field, final I18nLocale annotation, final Object component,
        final Context context, final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    try {
        final Object locale = Reflection.getFieldValue(field, component);
        if (locale instanceof Locale) {
            currentLocale.set((Locale) locale);
        } else if (locale instanceof String) {
            extractLocaleFromAnnotatedString(annotation, (String) locale);
        }
    } catch (final ReflectionException exception) {
        throw new GdxRuntimeException("Unable to extract application's locale.", exception);
    }

}

/** Utility method that allows to extract actual annotation from field, bypassing LibGDX annotation wrapper. Returns
 * null if annotation is not present.
 *
 * @param field might be annotated.
 * @param annotationType class of the annotation.
 * @return an instance of the annotation if the field is annotated or null if not. */
public static <Type extends Annotation> Type getAnnotation(final Field field, final Class<Type> annotationType) {
    if (isAnnotationPresent(field, annotationType)) {
        return field.getDeclaredAnnotation(annotationType).getAnnotation(annotationType);
    }
    return null;
}

/** @param field will be set accessible and extracted.
 * @param fieldOwner instance of class that contains the field.
 * @param fieldType class of the field. Will be used to cast the field object.
 * @return current field value.
 * @throws ReflectionException if unable to extract. */
@SuppressWarnings("unchecked")
public static <FieldType> FieldType getFieldValue(final Field field, final Object fieldOwner,
        final Class<FieldType> fieldType) throws ReflectionException {
    field.setAccessible(true);
    return (FieldType) field.get(fieldOwner);
}

/** Scans class tree of component to process all its fields.
 *
 * @param component all fields of its class tree will be processed.
 * @param context used to resolve dependencies.
 * @param contextDestroyer used to register destruction callbacks. */
private void processFields(final Object component, final Context context, final ContextDestroyer contextDestroyer) {
    Class<?> componentClass = component.getClass();
    while (componentClass != null && !componentClass.equals(Object.class)) {
        final Field[] fields = ClassReflection.getDeclaredFields(componentClass);
        if (fields != null && fields.length > 0) {
            processFields(component, fields, context, contextDestroyer);
        }
        componentClass = componentClass.getSuperclass();
    }
}

/** @param field will return an array of its annotations.
 * @return array of annotations or null. GWT utility. */
private static com.badlogic.gdx.utils.reflect.Annotation[] getAnnotations(final Field field) {
    try {
        return field.getDeclaredAnnotations();
    } catch (final Exception exception) {
        Exceptions.ignore(exception);
        return null;
    }
}

@Override
public void processField(final Field field, final Inject annotation, final Object component, final Context context,
        final ContextInitializer initializer, final ContextDestroyer contextDestroyer) {
    if (Annotations.isNotVoid(annotation.lazy())) {
        processLazyInjection(field, annotation, component, context);
    } else {
        processRegularInjection(field, annotation, component, context);
    }
}

/** @param field will have its value injected.
 * @param annotation used to determine dependency type.
 * @param component owner of the field.
 * @param context used to resolve dependencies. */
protected void processRegularInjection(final Field field, final Inject annotation, final Object component,
        final Context context) {
    final Class<?> dependencyClass = Annotations.isNotVoid(annotation.value()) ? annotation.value()
            : field.getType();
    setFieldValue(field, component, context.provide(dependencyClass));
}

/** @param field will return an array of its annotations.
 * @return array of annotations or null. GWT utility. */
private static com.badlogic.gdx.utils.reflect.Annotation[] getAnnotations(final Field field) {
    try {
        return field.getDeclaredAnnotations();
    } catch (final Exception exception) {
        Exceptions.ignore(exception);
        return null;
    }
}