Obteniendo actividad del contexto en Android

Este me tiene perplejo.

Necesito llamar a un método de actividad desde una clase de diseño personalizada. El problema con esto es que no sé cómo acceder a la actividad desde el diseño.

ProfileView

public class ProfileView extends LinearLayout
{
    TextView profileTitleTextView;
    ImageView profileScreenImageButton;
    boolean isEmpty;
    ProfileData data;
    String name;

    public ProfileView(Context context, AttributeSet attrs, String name, final ProfileData profileData)
    {
        super(context, attrs);
        ......
        ......
    }

    //Heres where things get complicated
    public void onClick(View v)
    {
        //Need to get the parent activity and call its method.
        ProfileActivity x = (ProfileActivity) context;
        x.activityMethod();
    }
}

PerfilActividad

public class ProfileActivityActivity extends Activity
{
    //In here I am creating multiple ProfileViews and adding them to the activity dynamically.

    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.profile_activity_main);
    }

    public void addProfilesToThisView()
    {
        ProfileData tempPd = new tempPd(.....)
        Context actvitiyContext = this.getApplicationContext();
        //Profile view needs context, null, name and a profileData
        ProfileView pv = new ProfileView(actvitiyContext, null, temp, tempPd);
        profileLayout.addView(pv);
    }
}

Como puede ver arriba, estoy instanciando el profileView programáticamente y pasando el ActivityContext con él. 2 preguntas:

1. ¿Estoy pasando el contexto correcto a Profileview?
2. ¿Cómo obtengo la actividad que contiene el contexto?

Desde su Activity, simplemente pase thiscomo Contextpara su diseño:

ProfileView pv = new ProfileView(this, null, temp, tempPd);

Luego tendrá un Contextdiseño, pero sabrá que es realmente suyo Activityy puede lanzarlo para que tenga lo que necesita:

Activity activity = (Activity) context;

Esto es algo que he utilizado con éxito para convertir Contexta Activityfuncionar dentro de la interfaz de usuario en fragmentos o vistas personalizadas. Descomprimirá ContextWrapper recursivamente o devolverá nulo si falla.

public Activity getActivity(Context context)
{
    if (context == null)
    {
        return null;
    }
    else if (context instanceof ContextWrapper)
    {
        if (context instanceof Activity)
        {
            return (Activity) context;
        }
        else
        {
            return getActivity(((ContextWrapper) context).getBaseContext());
        }
    }

    return null;
}

1. No
2. No puedes

Hay dos contextos diferentes en Android. Una para su aplicación (llamémosla GRANDE) y otra para cada vista (llamémosla contexto de actividad).

Un diseño lineal es una vista, por lo que debe llamar al contexto de actividad. Para llamarlo desde una actividad, simplemente llame "esto". ¿Tan fácil no es así?

Cuando usas

this.getApplicationContext();

Llama al contexto GRANDE, el que describe su aplicación y no puede administrar su vista.

Un gran problema con Android es que un contexto no puede llamar a su actividad. Es un gran problema evitar esto cuando alguien comienza con el desarrollo de Android. Debe encontrar una mejor manera de codificar su clase (o reemplazar "Contexto contextual" por "Actividad de actividad" y convertirlo en "Contexto" cuando sea necesario).

Saludos.

Solo para actualizar mi respuesta. La forma más fácil de obtener su Activity contextes definir una staticinstancia en su Activity. Por ejemplo

public class DummyActivity extends Activity
{
    public static DummyActivity instance = null;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        // Do some operations here
    }

    @Override
    public void onResume()
    {
        super.onResume();
        instance = this;
    }

    @Override
    public void onPause()
    {
        super.onPause();
        instance = null;
    }
}

Y luego, en su Task, Dialog, View, usted podría utilizar ese tipo de código para obtener su Activity context:

if (DummyActivity.instance != null)
{
    // Do your operations with DummyActivity.instance
}

Si desea llamar a un método de actividad desde una clase de diseño personalizada (no clase de actividad). Debe crear un delegado utilizando la interfaz.

No ha sido probado y lo codifiqué correctamente. pero estoy transmitiendo una forma de lograr lo que quieres.

Primero de todo crear e interfaz

interface TaskCompleteListener<T> {
   public void onProfileClicked(T result);
}



public class ProfileView extends LinearLayout
{
    private TaskCompleteListener<String> callback;
    TextView profileTitleTextView;
    ImageView profileScreenImageButton;
    boolean isEmpty;
    ProfileData data;
    String name;

    public ProfileView(Context context, AttributeSet attrs, String name, final ProfileData profileData)
    {
        super(context, attrs);
        ......
        ......
    }
    public setCallBack( TaskCompleteListener<String> cb) 
    {
      this.callback = cb;
    }
    //Heres where things get complicated
    public void onClick(View v)
    {
        callback.onProfileClicked("Pass your result or any type");
    }
}

E implemente esto en cualquier actividad.

y llámalo como

ProfileView pv = new ProfileView(actvitiyContext, null, temp, tempPd);
pv.setCallBack(new TaskCompleteListener
               {
                   public void onProfileClicked(String resultStringFromProfileView){}
               });

El contexto puede ser una Aplicación, un Servicio, una Actividad y más.

Normalmente, el contexto de Vistas en una Actividad es la Actividad en sí misma, por lo que puede pensar que puede convertir este Contexto en Actividad, pero en realidad no siempre puede hacerlo, porque el contexto también puede ser un ContextThemeWrapper en este caso.

ContextThemeWrapper se usa mucho en las versiones recientes de AppCompat y Android (gracias al atributo android: theme en los diseños), por lo que personalmente nunca realizaría este reparto.

Entonces, la respuesta corta es: no puede recuperar de manera confiable una Actividad de un Contexto en una Vista. Pase la Actividad a la vista llamando a un método que tome la Actividad como parámetro.

Nunca use getApplicationContext () con vistas.

Siempre debe ser el contexto de la actividad, ya que la vista se adjunta a la actividad. Además, es posible que tenga un conjunto de temas personalizado y, al usar el contexto de la aplicación, se perderá todo el tema. Lea más sobre diferentes versiones de contextos aquí .

Y en Kotlin:

tailrec fun Context.activity(): Activity? = when {
  this is Activity -> this
  else -> (this as? ContextWrapper)?.baseContext?.activity()
}

una Actividad es una especialización de Contexto, por lo tanto, si tiene un Contexto ya sabe qué actividad tiene intención de usar y simplemente puede convertir a en c ; donde a es una actividad yc es un contexto.

Activity a = (Activity) c;

Solía ​​convertir Actividad

Activity activity = (Activity) context;

Este método debería ser útil ...!

public Activity getActivityByContext(Context context){

if(context == null){
    return null;
    }

else if((context instanceof ContextWrapper) && (context instanceof Activity)){
        return (Activity) context;
    }

else if(context instanceof ContextWrapper){
        return getActivity(((ContextWrapper) context).getBaseContext());
    }

return null;

    }

Espero que esto ayude. ¡Feliz codificación!

¿qué tal una devolución de llamada de datos en vivo,

class ProfileView{
    private val _profileViewClicked = MutableLiveData<ProfileView>()
    val profileViewClicked: LiveData<ProfileView> = _profileViewClicked
}

class ProfileActivity{

  override fun onCreateView(...){

    profileViewClicked.observe(viewLifecycleOwner, Observer { 
       activityMethod()
    })
  }

}