Uzyskiwanie aktywności z kontekstu w Androidzie

Ten mnie zaskoczył.

Muszę wywołać metodę działania z niestandardowej klasy układu. Problem polega na tym, że nie wiem, jak uzyskać dostęp do działania z poziomu układu.

Widok profilu

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();
    }
}

ProfileActivity

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);
    }
}

Jak widać powyżej, tworzę programowo instancję ProfileView i przekazuję z nią działanie ActivityContext. 2 pytania:

1. Czy przekazuję poprawny kontekst do Profileview?
2. Jak uzyskać aktywność zawierającą z kontekstu?

Po Activityprostu podaj thisjako Contextswój układ:

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

Następnie będziesz mieć Contextukład, ale będziesz wiedział, że to rzeczywiście twój Activityi możesz go rzucić, aby mieć to, czego potrzebujesz:

Activity activity = (Activity) context;

To jest coś, co z powodzeniem stosowany do konwersji Context, aby Activitypodczas pracy w interfejsie we fragmentach lub widoków niestandardowych. Rozpakuje rekursywnie ContextWrapper lub zwróci null, jeśli się nie powiedzie.

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. Nie
2. Nie możesz

W Androidzie istnieją dwa różne konteksty. Jeden dla Twojej aplikacji (nazwijmy to DUŻYM) i jeden dla każdego widoku (nazwijmy to kontekstem działania).

Liniowy układ jest widokiem, więc musisz wywołać kontekst działania. Aby nazwać to z działania, po prostu nazywaj to. To takie proste, prawda?

Kiedy używasz

this.getApplicationContext();

Wywołujesz kontekst BIG, ten, który opisuje twoją aplikację i nie może zarządzać twoim widokiem.

Dużym problemem związanym z Androidem jest to, że kontekst nie może wywołać Twojej aktywności. To wielka sprawa, aby tego uniknąć, gdy ktoś zaczyna od opracowania Androida. Musisz znaleźć lepszy sposób na zakodowanie swojej klasy (lub zastąp „Kontekst kontekstowy” przez „Aktywność aktywności” i w razie potrzeby przenieś go na „Kontekst”).

Pozdrowienia.

Aby zaktualizować moją odpowiedź. Najłatwiejszym sposobem na uzyskanie tego Activity contextjest zdefiniowanie staticinstancji w twoim Activity. Na przykład

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;
    }
}

A potem, w twoich Task, Dialog, View, można użyć tego rodzaju kodu, aby otrzymać Activity context:

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

Jeśli chcesz wywołać metodę działania z niestandardowej klasy układu (innej niż klasa aktywności). Powinieneś utworzyć delegata za pomocą interfejsu.

Jest nieprzetestowany i poprawnie go zakodowałem. ale przekazuję sposób na osiągnięcie tego, co chcesz.

Po pierwsze tworzenie i interfejs

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");
    }
}

I zaimplementuj to do dowolnego działania.

i nazwać to tak

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

Kontekstem może być Aplikacja, Usługa, Działanie i wiele innych.

Zwykle kontekstem widoków w działaniu jest samo działanie, więc możesz pomyśleć, że możesz po prostu rzucić ten kontekst na działanie, ale tak naprawdę nie zawsze możesz to zrobić, ponieważ w tym przypadku kontekstem może być również ContextThemeWrapper.

ContextThemeWrapper jest intensywnie używany w najnowszych wersjach AppCompat i Androida (dzięki androidowi: atrybut motywu w układach), więc osobiście nigdy nie wykonałbym tego rzutowania.

Krótka odpowiedź brzmi: nie można w sposób wiarygodny odzyskać działania z kontekstu w widoku. Przekaż działanie do widoku, wywołując metodę, która przyjmuje działanie jako parametr.

Nigdy nie używaj getApplicationContext () z widokami.

Zawsze powinien to być kontekst działania, ponieważ widok jest dołączony do działania. Ponadto możesz mieć niestandardowy zestaw motywów, a podczas korzystania z kontekstu aplikacji wszystkie motywy zostaną utracone. Przeczytaj więcej o różnych wersjach kontekstów tutaj .

A w Kotlinie:

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

działalności jest specjalizacja z kontekstu tak, jeśli masz Context już znasz których działalność masz zamiar używać, a może po prostu rzucić do c ; gdzie a jest działaniem, a c jest kontekstem.

Activity a = (Activity) c;

Użyłem konwersji działania

Activity activity = (Activity) context;

Ta metoda powinna być pomocna ..!

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;

    }

Mam nadzieję, że to pomoże .. Wesołego kodowania!

co powiesz na niektóre wywołania zwrotne danych na żywo,

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

class ProfileActivity{

  override fun onCreateView(...){

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

}