Como posso obter o contexto em um fragmento?

Preciso usar meu banco de dados cujo construtor aceita o contexto, mas, getApplicationContext()e FragmentClass.thisnão funciona, o que posso fazer?

Construtor de banco de dados

public Database(Context ctx)
{
    this.context = ctx;
    DBHelper = new DatabaseHelper(context);
}

Você pode usar getActivity(), que retorna a atividade associada a um fragment.
A atividade é uma context (já que Activityse estende Context) .

Para fazer como a resposta acima, você pode substituir o onAttachmétodo do fragmento:

public static class DummySectionFragment extends Fragment{
...
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        DBHelper = new DatabaseHelper(activity);
    }
}

Sempre use o método getActivity () para obter o contexto de sua atividade anexada, mas lembre-se sempre de uma coisa: os fragmentos são um pouco instáveis ​​e getActivityretornam nulos algumas vezes; portanto, sempre verifique o método isAdded () do fragmento antes de obter o contexto getActivity().

A maneira mais fácil e precisa de obter o contexto do fragmento que encontrei é obtê-lo diretamente a partir do ViewGroupmomento em que você chamar o onCreateViewmétodo, pelo menos aqui, você tem certeza de que não será nulo por getActivity():

public class Animal extends Fragment { 
  Context thiscontext;
  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
  {
    thiscontext = container.getContext();

Anteriormente eu estou usando onAttach (Activity activity)para chegar contextemFragment

Problema

O onAttach (Activity activity)método foi descontinuado no nível 23 da API.

Solução

Agora, para obter contexto Fragment, podemos usaronAttach (Context context)

onAttach (Context context)

• Chamado quando um fragmento é anexado pela primeira vez a ele context. onCreate(Bundle)será chamado depois disso.

Documentação

/**
 * Called when a fragment is first attached to its context.
 * {@link #onCreate(Bundle)} will be called after this.
 */
@CallSuper
public void onAttach(Context context) {
    mCalled = true;
    final Activity hostActivity = mHost == null ? null : mHost.getActivity();
    if (hostActivity != null) {
        mCalled = false;
        onAttach(hostActivity);
    }
}

CÓDIGO DE AMOSTRA

public class FirstFragment extends Fragment {


    private Context mContext;
    public FirstFragment() {
        // Required empty public constructor
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        mContext=context;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View rooView=inflater.inflate(R.layout.fragment_first, container, false);

        Toast.makeText(mContext, "THIS IS SAMPLE TOAST", Toast.LENGTH_SHORT).show();
        // Inflate the layout for this fragment
        return rooView;
    }

}

NOTA

Também podemos usar getActivity()para entrar context, Fragments mas getActivity()podemos retornar nullse o seu fragmentnão estiver atualmente anexado a um pai activity,

@Override
public void onAttach(Activity activity) {
    // TODO Auto-generated method stub
    super.onAttach(activity);
    context=activity;
}

Você também pode obter o contexto do inflaterparâmetro, ao substituir onCreateView.

public static class MyFragment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
        /* ... */
        Context context = inflater.getContext();
        /* ... */
    }
}

Outra abordagem alternativa é:

Você pode obter o contexto usando:

getActivity().getApplicationContext();

para obter o contexto dentro do fragmento será possível usando getActivity():

public Database()
{
    this.context = getActivity();
    DBHelper = new DatabaseHelper(this.context);
}

• Cuidado, para usar o Activityassociado ao fragmento getActivity(), você pode usá-lo, mas não é recomendável, pois isso causará vazamentos de memória.

Eu acho que uma abordagem melhor deve estar recebendo Activityo onAttach()método:

@Override
public void onAttach(Activity activity) {
    super.onAttach(activity);
    context = activity;
}

getContext() veio na API 23. Substitua-o por getActivity () em todo o código.

Veja se ele corrige o erro. Tente usar métodos que estejam entre o nível mínimo e mínimo da API, caso contrário, esse erro ocorrerá.

Desde nível API 23 não é getContext(), mas se você quer apoiar as versões mais antigas que você pode usar getActivity().getApplicationContext()enquanto eu ainda recomendo usar a versão apoio do Fragmentque é android.support.v4.app.Fragment.

getActivity() é um filho do contexto, de modo que deve funcionar para você

Use fragmentos da Biblioteca de suporte -

android.support.v4.app.Fragment

e depois substituir

void onAttach (Context context) {
  this.context = context;
}

Dessa forma, você pode ter certeza de que o contexto sempre será um valor não nulo.

Você tem opções diferentes:

• Se seu minSDK <= 21, você pode usar getActivity(), pois esse é um Context.
• Se o seu minSDK for> = 23, você poderá usá-lo getContext().

Se você não precisa oferecer suporte a versões antigas, continue com getContext().

Para o Kotlin, você pode usar contextdiretamente em fragmentos. Mas, em alguns casos, você encontrará um erro como

Incompatibilidade de tipos: o tipo inferido é Contexto? mas o contexto era esperado

para isso você pode fazer isso

val ctx = context ?: return
textViewABC.setTextColor(ContextCompat.getColor(ctx, android.R.color.black))

No kotlin, basta usar em activityvez degetActivity()

Com a API 29+ no Kotlin, eu tive que fazer

activity?.applicationContext!!

Um exemplo seria

ContextCompat.getColor(activity?.applicationContext!!, R.color.colorAccent),

Idealmente, você não precisa usar globals. O fragmento possui notificações diferentes, sendo uma delas onActivityCreated. Você pode obter a instância da atividade neste evento de ciclo de vida do fragmento.

Então: você pode desreferenciar o fragmento para obter a atividade, o contexto ou o contexto da aplicação como desejar:

this.getActivity()fornecerá o identificador para a atividade this.getContext(), fornecerá o identificador para o contexto this.getActivity().getApplicationContext(), fornecerá o identificador para o contexto do aplicativo. De preferência, você deve usar o contexto do aplicativo ao transmiti-lo para o banco de dados.

A maneira mais simples é usar getActivity(). Mas acho que a maior confusão de usar ogetActivity() método para obter o contexto aqui é uma exceção de ponteiro nulo.

Para isso, verifique primeiro com o isAdded()método que determinará se ele foi adicionado ou não e, em seguida, podemos usar o getActivity()para obter o contexto de Activity.

Você pode ligar getActivity()ou,

public void onAttach(Context context) {
    super.onAttach(context);
    this.activity = (CashActivity) context;
    this.money = this.activity.money;
}

Você pode usar o método getActivity () para obter contexto ou Você pode usar o método getContext ().

 View root = inflater.inflate(R.layout.fragment_slideshow, container, false);
    Context c = root.getContext();

Espero que ajude!

O método getContext () ajuda a usar o contexto da classe em uma atividade de fragmento.

Eu acho que você pode usar

public static class MyFragment extends Fragment {
  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

      Context context = getActivity.getContext();

  }
}

public class MenuFragment extends Fragment implements View.OnClickListener {
    private Context mContext;
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        FragmentMenuBinding binding=FragmentMenuBinding.inflate(inflater,container,false);
        View view=binding.getRoot();
        mContext=view.getContext();
        return view;
    }
}

Também você pode usar:

inflater.getContext();

mas eu preferiria usar

getActivity()

ou

getContext

Eu preciso de contexto para usar o fragmento arrayAdapter IN, quando eu estava usando o erro getActivity, mas quando eu o substituo por getContext, ele funciona para mim

listView LV=getView().findViewById(R.id.listOFsensors);
LV.setAdapter(new ArrayAdapter<String>(getContext(),android.R.layout.simple_list_item_1 ,listSensorType));

Você pode usar getActivity()ougetContext no fragmento.

Documentação

/**
 * Return the {@link FragmentActivity} this fragment is currently associated with.
 * May return {@code null} if the fragment is associated with a {@link Context}
 * instead.
 *
 * @see #requireActivity()
 */
@Nullable
final public FragmentActivity getActivity() {
    return mHost == null ? null : (FragmentActivity) mHost.getActivity();
}

e

 /**
     * Return the {@link Context} this fragment is currently associated with.
     *
     * @see #requireContext()
     */
    @Nullable
    public Context getContext() {
        return mHost == null ? null : mHost.getContext();
    }

Dica profissional

Verifique sempre, if(getActivity!=null)pois pode ser nulo quando o fragmento não está anexado à atividade. Às vezes, fazer uma operação longa no fragmento (como buscar dados da API restante) leva algum tempo. e se o usuário navegar para outro fragmento. Então, getActivity será nulo. E você receberá o NPE se não o tiver tratado.

Em seu fragmento

((Name_of_your_Activity) getActivity()).helper

Em atividade

DbHelper helper = new DbHelper(this);

Fragmento interno para amostra kotlin ajudaria alguém

textViewStatus.setTextColor(ContextCompat.getColor(context!!, R.color.red))

se você usar a ligação de dados;

bindingView.textViewStatus.setTextColor(ContextCompat.getColor(context!!, R.color.red))

Onde bindingView é inicializado em onCreateView como este

private lateinit var bindingView: FragmentBookingHistoryDetailBinding

bindingView = DataBindingUtil.inflate(inflater, R.layout.your_layout_xml, container, false)

O método requireContext () é a opção mais simples

requireContext()

Exemplo

MyDatabase(requireContext())