user interface - BlackBerry-Diversión con FieldManagers

user-interface layout

Question

Estoy tratando de crear una clase de Vista que proporcione un diseño Horizontal o Vertical según cómo se cree. Estoy usando un delegado para lograr esto.

class View extends Manager {
    private Manager mDelegate;

    public View(Manager inDelegate) {
        mDelegate = inDelegate;
        // the delegate is the only child of "this" manager.
        super.add(mDelegate);
    }

    public void add(Field f) {
        // all other children go into the delegate.    
        mDelegate.add(f);
    }

    // other methods that also delegate

}

Cuando instancia un objeto de vista, paso en un administrador de campo horizontal o vertical y luego delego llamadas a eso. Esto es un poco lo que hace la clase Screen en blackberry.

En realidad, estoy mirando los documentos de Blackberry para Screen para ver qué llamadas son delegadas (para poder emular eso) y veo llamadas como esta en Screen ...

protected boolean keyChar (char c, int estado, int time)

Delega el evento de generación de claves al campo controlado con enfoque. Este método invoca Manager.keyChar (char, int, int) en el administrador de delegados de esta pantalla.

Entonces, de inmediato me doy cuenta, ¿cómo demonios están llamando a un método protegido en el delegado de la pantalla? ¿O los documentos están equivocados y este método no está delegado?

Alguien sabe cómo lo logran?

Answer 1

Recordarme a mí mismo lo que significa proteger :

Un método protegido puede ser llamado por cualquier subclase dentro de su clase, pero no por clases no relacionadas.

Esto no responde directamente a su pregunta, pero ¿podría extender Screen ( API aquí ) en lugar de Manager y luego llamar a super(mDelegate) en su constructor? Entonces, presumiblemente, cualquier magia que sea necesaria ¿funcionará?

Aparte de eso, solo te sugiero que lo pruebes y veas si puedes anular el método supuestamente protegido.

Answer 2

Me las arreglé para encontrar una solución a este problema con la ayuda de algunas otras preguntas de SO.

Mi solución es crear una interfaz que proporcione los puntos de acceso público para los métodos protegidos y luego subclasifique la clase Manager y mezcle esa interfaz. El método público llamará al método protegido de su súper.

Luego, la clase View pasa a una de estas subclases de Manager.

public interface ManagerDelegate {
    Manager asManager();
    // Provide public access points to any protected methods needed.
    void doProtectedMethod();
}

public HorizontalDelegate extends HorizontalFieldManager implements ManagerDelegate {
    public Manager asManager() {
        return this;
    }
    public void doProtectedMethod() {
        // call the Manager''s protected method.
        protectedMethod();
    }
}

public VerticalDelegate extends VerticalFieldManager implements ManagerDelegate {
    public Manager asManager() {
        return this;
    }
    public void doProtectedMethod() {
        // call the Manager''s protected method.
        protectedMethod();
    }
}

public class View extends Manager {
    private final ManagerDelegate mDelegate;

    public View(ManagerDelegate inDelegate) {
        mDelegate = inDelegate;
    }

    protected void protectedMethod() {
        // Call into our delegate''s public method to access its protected method.
        mDelegate.doProtectedMethod();
    }

    public void publicMethod() {
        // For public delegated methods I can just get the Manager instance from
        // the delegate and call directly.
        mDelegate.asManager().publicMethod();
    }
}