O ProgressDialog foi descontinuado. Qual é a alternativa a ser usada?

213

Eu vim para ver que ProgressDialogagora está obsoleto. O que seria um alternativo para usar no lugar disso, além de ProgressBar? Estou usando a versão 2.3.3 do android studio.

ProgressDialog progressDialog=new ProgressDialog(this);
progressDialog.show();
Sunil P
fonte
Possível duplicado de ProgressDialog está obsoleto
Lalit Jadav

Respostas:

196

Sim, API level 26está obsoleto. Em vez disso, você pode usar progressBar.

Para criá-lo programaticamente:

Primeiro, obtenha uma referência ao layout raiz

RelativeLayout layout = findViewById(R.id.display);  //specify here Root layout Id

ou

RelativeLayout layout = findViewById(this);

Em seguida, adicione a barra de progresso

progressBar = new ProgressBar(youractivity.this, null, android.R.attr.progressBarStyleLarge);
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(100, 100);
params.addRule(RelativeLayout.CENTER_IN_PARENT);
layout.addView(progressBar, params);

Para mostrar a barra de progresso

progressBar.setVisibility(View.VISIBLE);

Para ocultar a barra de progresso

progressBar.setVisibility(View.GONE);

Para desativar a interação do usuário, você só precisa adicionar o seguinte código

getWindow().setFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
                           WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

Para recuperar a interação do usuário, basta adicionar o seguinte código

getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);

Apenas para referência futura, altere android.R.attr.progressBarStyleSmallpara android.R.attr.progressBarStyleHorizontal.

O código abaixo funciona apenas acima API level 21

progressBar.setProgressTintList(ColorStateList.valueOf(Color.RED));

Para criá-lo via xml:

<ProgressBar
        android:id="@+id/progressbar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:indeterminate="true"
        android:max="100"
        android:backgroundTint="@color/white"
        android:layout_below="@+id/framelauout"
        android:indeterminateTint="#1a09d6"
        android:layout_marginTop="-7dp"/>

Na sua atividade

progressBar = (ProgressBar) findViewById(R.id.progressbar);

Mostrar / ocultar a barra de progresso é o mesmo

 progressBar.setVisibility(View.VISIBLE); // To show the ProgressBar 
 progressBar.setVisibility(View.INVISIBLE); // To hide the ProgressBar

Aqui está uma imagem de exemplo de como seria:

Para mais detalhes:
1. Referência um
2. Referência dois

Gowthaman M
fonte
É como se você estivesse usando isso e você diria que sim, finalmente o diálogo de progresso está obsoleto, para que eu possa mostrar meu potencial para o mundo: D, estou brincando, muito obrigado por essa resposta detalhada.
Mohamed Hajr 21/01
1
mas como definirMessage ()?
Devie_ss
atualize o código XML para "@android: cor / branco"
musterjunk
Para obter a barra horizontal, use: ProgressBar progressBar = new ProgressBar (youractivity.this, null, android.R.attr.progressBarStyleHorizontal); progressBar.setIndeterminate (true);
taranjeetsapra 28/01/19
43

você pode usar AlertDialogcomo se ProgressDialogrefere abaixo código para o ProgressDialog. Essa função você precisa chamar sempre que mostrar uma caixa de diálogo de progresso.

Código:

    public void setProgressDialog() {

    int llPadding = 30;
    LinearLayout ll = new LinearLayout(this);
    ll.setOrientation(LinearLayout.HORIZONTAL);
    ll.setPadding(llPadding, llPadding, llPadding, llPadding);
    ll.setGravity(Gravity.CENTER);
    LinearLayout.LayoutParams llParam = new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.WRAP_CONTENT,
            LinearLayout.LayoutParams.WRAP_CONTENT);
    llParam.gravity = Gravity.CENTER;
    ll.setLayoutParams(llParam);

    ProgressBar progressBar = new ProgressBar(this);
    progressBar.setIndeterminate(true);
    progressBar.setPadding(0, 0, llPadding, 0);
    progressBar.setLayoutParams(llParam);

    llParam = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
            ViewGroup.LayoutParams.WRAP_CONTENT);
    llParam.gravity = Gravity.CENTER;
    TextView tvText = new TextView(this);
    tvText.setText("Loading ...");
    tvText.setTextColor(Color.parseColor("#000000"));
    tvText.setTextSize(20);
    tvText.setLayoutParams(llParam);

    ll.addView(progressBar);
    ll.addView(tvText);

    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setCancelable(true);
    builder.setView(ll);

    AlertDialog dialog = builder.create();
    dialog.show();
    Window window = dialog.getWindow();
    if (window != null) {
        WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
        layoutParams.copyFrom(dialog.getWindow().getAttributes());
        layoutParams.width = LinearLayout.LayoutParams.WRAP_CONTENT;
        layoutParams.height = LinearLayout.LayoutParams.WRAP_CONTENT;
        dialog.getWindow().setAttributes(layoutParams);
    }
}

Resultado:

insira a descrição da imagem aqui

Kishan Donga
fonte
Como descartá-lo?
Jay Dangar
1
fazer uma classe de base como BaseActivity em seguida, depois de adicionar este pedaço de código, também adicionar um método de diálogo descartar, mas para isso, você precisa definir 'AlertDialog de diálogo' objeto globalmente
Kishan Donga
então simplesmente chame o método dialog.dismiss () dentro do seu método de ocultar o diálogo.
Kishan Donga
1
Tudo está bem, mas ao tocar em qualquer lugar da caixa de diálogo da tela, é dispensado. As chamadas de serviço em andamento e o processo são capazes de descartá-lo e brincar com a interface do usuário, o que não é bom.
Vivek Kumar
Você pode configurá-lo como não cancelável, mas, se girar o dispositivo ou usar a tela dividida, ele será descartado de qualquer maneira e o usuário poderá interagir com a interface do usuário que não está pronta. Talvez AlertDialognão deva ser usado aqui.
Meow Cat 2012
30

Esta classe foi descontinuada no nível 26 da API. ProgressDialog é uma caixa de diálogo modal, que impede o usuário de interagir com o aplicativo. Em vez de usar essa classe, você deve usar um indicador de progresso como ProgressBar, que pode ser incorporado na interface do usuário do seu aplicativo. Como alternativa, você pode usar uma notificação para informar o usuário sobre o progresso da tarefa. ligação

Foi descontinuado Android Odevido ao Googlenovo padrão de interface do usuário

Oussema Aroua
fonte
1
"Esta classe foi descontinuada no nível 26 da API" é usada em vez de uma data. Eles não querem que você use mais. Sim, é por causa dos novos padrões de interface do usuário, mas eles se aplicam a todos os níveis da API ...
creativecreatorormaybenot
28
"É obsoleto em Android O por causa do Google padrão nova UI" - ligação agradar novo padrão UI
Ajay S
22
E a razão para descontinuá-lo é porque ele bloqueia a entrada do usuário? Às vezes me pergunto que tipo de pó os engenheiros do Google estão bufando. É muito mais fácil usar uma caixa de diálogo de bloqueio do que ter que ocultar / desativar os controles de entrada e, em seguida, ativar uma barra de progresso. Pensamento tolo da parte do Google.
TheRealChx101
@ TheRealChx101 A interface do usuário do Android foi projetada para fazer com que o usuário sinta uma falsa sensação de liberdade ao custo de soluções alternativas caras para evitar erros fatais resultantes dela. Aguarde até obter as permissões e o que as operadoras pagaram ao Google para dizer que você pode e não pode acessar.
Abandoned Cart
3
Eu acho que eles estão mais interessados ​​em impedir o abuso de diálogos modais: às vezes eles são mostrados para fazer o usuário esperar pelo final de uma operação em circunstâncias nas quais o usuário não precisa esperar, mas pode continuar fazendo outras coisas , fazendo-os esperar desnecessariamente prejudica a experiência do usuário. Não obstante, há muitas circunstâncias em que não há escolha para o usuário, mas aguarde a conclusão da operação, por isso concordo que deve haver um método padrão não preterido para esses casos, em vez de forçar cada desenvolvedor a implementar seu próprio.
Fran Marzoa
25

Você pode simplesmente criar uma interface xml para sua barra de progresso e passá-la como uma exibição para um AlertDialog, depois mostrar ou descartar a caixa de diálogo a qualquer momento.

progress.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:padding="13dp"
    android:layout_centerHorizontal="true"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <ProgressBar
        android:id="@+id/loader"
        android:layout_marginEnd="5dp"
        android:layout_width="45dp"
        android:layout_height="45dp" />
    <TextView
        android:layout_width="wrap_content"
        android:text="Loading..."
        android:textAppearance="?android:textAppearanceSmall"
        android:layout_gravity="center_vertical"
        android:id="@+id/loading_msg"
        android:layout_toEndOf="@+id/loader"
        android:layout_height="wrap_content" />

</LinearLayout>

O código do código que exibe a caixa de diálogo de progresso. Basta copiar esse código e colá-lo em seu fragmento.

  AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
       private void setDialog(boolean show){
            builder.setView(R.layout.progress);
            Dialog dialog = builder.create();
            if (show)dialog.show();
            else dialog.dismiss();
        }

Em seguida, basta chamar o método sempre que desejar mostrar o diálogo de progresso e passar verdadeiro como argumento para mostrá-lo ou falso para descartar a caixa de diálogo.

DevMike01
fonte
2
@Alok Rajasukumaran parece que você está usando atividade, basta substituí-lo por this, para que AlertDialog.Builder builder = new AlertDialog.Builder(this);fique assim . Certifique-se de copiar o código certo.
precisa saber é o seguinte
1
layout_toEndOfpode ser removido desde que não sejaLinearLayout
Mark
21

O ProgressBar é muito simples e fácil de usar, pretendo fazer o mesmo que o simples diálogo de progresso. O primeiro passo é criar o layout em xml da caixa de diálogo que deseja mostrar, digamos que o nome desse layout

layout_loading_dialog.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal"
    android:padding="20dp">
    <ProgressBar
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1" />

    <TextView
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="4"
        android:gravity="center"
        android:text="Please wait! This may take a moment." />
</LinearLayout>

O próximo passo é criar o AlertDialog que mostrará esse layout com o ProgressBar

AlertDialog.Builder builder = new AlertDialog.Builder(context);
builder.setCancelable(false); // if you want user to wait for some process to finish,
builder.setView(R.layout.layout_loading_dialog);
AlertDialog dialog = builder.create();

agora tudo o que resta é mostrar e ocultar esse diálogo em nossos eventos de clique como este

dialog.show(); // to show this dialog
dialog.dismiss(); // to hide this dialog

e é isso, deve funcionar, como você pode ver, é muito simples e fácil de implementar ProgressBar em vez de ProgressDialog. agora você pode mostrar / descartar esta caixa de diálogo no Handler ou no ASyncTask, depende de sua necessidade

Syed Naeem
fonte
Por favor, mude progress_dialog.show();para builder.show();. Obrigado.
Matheus Miranda
2
Alterei o nome para o objeto AlertDialog correto em show()/ dismiss(), mas não o coloquei builder.show()porque, para descartá-lo, teríamos que fazer o dialog.dismiss()que é meio confuso para alguém que gosta de manter seu código simples e fácil de entender, e também porque builder.show()retornos AlertDialogobjeto, e vamos ter de salvar essa referência como AlertDialog dialog = builder.show();então fazer dialog.dismiss(), é mais fácil ter builder.create()retorno em algum AlertDialogobjeto e, em seguida, usar esse objeto para mostrar e ocultar o diálogo
Syed Naeem
Podemos usar "runOnUiThread (new Runnable () {@Override public void run () {dialog.show/dismiss ();}});", se o segmento de chamada não for o segmento principal da interface do usuário. (útil quando usamos a chamada do WebView - deveria substituir métodos.)
SHS
15

Sim, o ProgressDialog está obsoleto, mas o Dialog não está.

Você pode inflar seu próprio arquivo XML (contendo uma barra de progresso e um texto carregado) em seu objeto de diálogo e depois exibi-lo ou ocultá-lo usando as funções show()e dismiss(). Aqui está um exemplo (Kotlin):

Classe ProgressDialog :

class ProgressDialog {
companion object {
    fun progressDialog(context: Context): Dialog{
        val dialog = Dialog(context)
        val inflate = LayoutInflater.from(context).inflate(R.layout.progress_dialog, null)
        dialog.setContentView(inflate)
        dialog.setCancelable(false)
        dialog.window!!.setBackgroundDrawable(
                ColorDrawable(Color.TRANSPARENT))
        return dialog
    }
  }
}

XML

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent"
android:background="#fff"
android:padding="13dp"
android:layout_height="wrap_content">
<ProgressBar
    android:id="@+id/progressBar"
    style="?android:attr/progressBarStyle"
    android:layout_width="100dp"
    android:layout_margin="7dp"
    android:layout_height="100dp"
    android:layout_above="@+id/no_jobs_pickups"/>
<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerVertical="true"
    android:layout_margin="7dp"
    android:layout_toEndOf="@+id/progressBar"
    android:text="Loading..." />
</RelativeLayout>

No seu código : façavar dialog = ProgressDialog.progressDialog(context)

Mostrar: dialog.show()

Esconder: dialog.dismiss()

Han
fonte
11

Bem, se você realmente quer ir contra a vontade deles, ainda pode usar o Sweet Alert Dialog ou criar um por conta própria.

progress_dialog_layout

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TableRow
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="64dp" >

        <ProgressBar
            android:id="@+id/progressBar2"
            style="?android:attr/progressBarStyle"
            android:layout_width="wrap_content"
            android:layout_height="match_parent" />

        <TextView
            android:gravity="center|left"
            android:id="@+id/textView9"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:textColor="@color/black"
            android:textSize="18sp"
            android:text="Downloading data. Please wait.." />
    </TableRow>
</RelativeLayout>

Código Java:

AlertDialog b;
AlertDialog.Builder dialogBuilder;

public void ShowProgressDialog() {
dialogBuilder = new AlertDialog.Builder(DataDownloadActivity.this);
LayoutInflater inflater = (LayoutInflater) getSystemService( Context.LAYOUT_INFLATER_SERVICE );
            View dialogView = inflater.inflate(R.layout.progress_dialog_layout, null);
            dialogBuilder.setView(dialogView);
            dialogBuilder.setCancelable(false);
            b = dialogBuilder.create();
            b.show();
        }

        public void HideProgressDialog(){

            b.dismiss();
        }
Ramesh Jaya
fonte
2
Eu tive experiências terríveis com o SweetAlertDialog em um ambiente de produção, seja muito cauteloso, pois vaza de janela em janela.
Jeremy
para mim HideProgressnão faz nada.
Saeed Neamati
1
Por que usar uma biblioteca apenas para mostrar uma caixa de diálogo de progresso?
Khemraj
6

ProgressBar é a melhor alternativa para ProgressDialog. Um elemento da interface do usuário que indica o progresso de uma operação.

Para mais informações, consulte este documento do Google: https://developer.android.com/reference/android/widget/ProgressBar.html

Furqan
fonte
16
Ele disse "além da barra de progresso".
creativecreatorormaybenot
6

Você não precisa importar nenhuma biblioteca personalizada.

Eu prefiro usar o moderno, AlertDialogentão esta é a versão do Kotlin para a ótima resposta postada por Kishan Donga nesta página.

Código Kotlin:

fun setProgressDialog(context:Context, message:String):AlertDialog {
    val llPadding = 30
    val ll = LinearLayout(context)
    ll.orientation = LinearLayout.HORIZONTAL
    ll.setPadding(llPadding, llPadding, llPadding, llPadding)
    ll.gravity = Gravity.CENTER
    var llParam = LinearLayout.LayoutParams(
                  LinearLayout.LayoutParams.WRAP_CONTENT,
                  LinearLayout.LayoutParams.WRAP_CONTENT)
    llParam.gravity = Gravity.CENTER
    ll.layoutParams = llParam

    val progressBar = ProgressBar(context)
    progressBar.isIndeterminate = true
    progressBar.setPadding(0, 0, llPadding, 0)
    progressBar.layoutParams = llParam

    llParam = LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
                        ViewGroup.LayoutParams.WRAP_CONTENT)
    llParam.gravity = Gravity.CENTER
    val tvText = TextView(context)
    tvText.text = message
    tvText.setTextColor(Color.parseColor("#000000"))
    tvText.textSize = 20.toFloat()
    tvText.layoutParams = llParam

    ll.addView(progressBar)
    ll.addView(tvText)

    val builder = AlertDialog.Builder(context)
    builder.setCancelable(true)
    builder.setView(ll)

    val dialog = builder.create()
    val window = dialog.window
    if (window != null) {
        val layoutParams = WindowManager.LayoutParams()
        layoutParams.copyFrom(dialog.window?.attributes)
        layoutParams.width = LinearLayout.LayoutParams.WRAP_CONTENT
        layoutParams.height = LinearLayout.LayoutParams.WRAP_CONTENT
                dialog.window?.attributes = layoutParams
    }
    return dialog
}

Uso:

val dialog = setProgressDialog(this, "Loading..")
dialog.show()

Resultado:

insira a descrição da imagem aqui

Alessandro Ornano
fonte
como usar em fragmento? o que é contexto em fragmento?
hosseini roghayeh
Normalmente em seu fragmento você pode obter seu ponto de vista atual, de modo que o contexto deve ser:view!!.context
Alessandro Ornano
4

Conforme mencionado na página de documentação, a alternativa é ProgressBar . ProgressDialogA aparência de pode ser replicada colocando um ProgressBarem um AlertDialog.

Você ainda pode usá-lo, mas o Android não deseja que você o use, é por isso que está obsoleto. Portanto, considere resolver seu problema de outra maneira, como incorporar um ProgressBarno seu Layout.

creativecreatorormaybenot
fonte
@PeterHaddad Funciona "normalmente" na API 28 no meu projeto e o mesmo que na API inferior. Como a depreciação sugere, ela não é mais suportada e pode não funcionar no futuro.
DMonkey
3

ProgressDialog foi descontinuado no nível da API 26.

"Deprecated" refere-se a funções ou elementos que estão em processo de substituição por outros mais novos.

ProgressDialog é uma caixa de diálogo modal, que impede o usuário de interagir com o aplicativo. Em vez de usar esta classe, você deve usar um indicador de progresso como ProgressBar, que pode ser incorporado na interface do usuário do seu aplicativo.

Vantagem

Eu diria pessoalmente que ProgressBartem vantagem sobre os dois. ProgressBaré um elemento da interface do usuário que indica o progresso de uma operação. Exibir barras de progresso para um usuário de maneira ininterrupta . Mostre a barra de progresso na interface do usuário do seu aplicativo.

IntelliJ Amiya
fonte
2

Uso DelayedProgressDialog em https://github.com/Q115/DelayedProgressDialog Ele faz o mesmo que ProgressDialog com o benefício adicional de um atraso, se necessário.

Usá-lo é semelhante ao ProgressDialog antes do Android O:

DelayedProgressDialog progressDialog = new DelayedProgressDialog();
progressDialog.show(getSupportFragmentManager(), "tag");
NinjaCowgirl
fonte
2

Você pode usar essa classe que escrevi. Ele oferece apenas as funções básicas. Se você deseja um ProgressDialog totalmente funcional, use esta biblioteca leve .

Configuração Gradle

Adicione a seguinte dependência ao module / build.gradle:

compile 'com.lmntrx.android.library.livin.missme:missme:0.1.5'

Como usá-lo?

O uso é semelhante ao ProgressDialog original

ProgressDialog progressDialog = new 
progressDialog(YourActivity.this);
progressDialog.setMessage("Please wait");
progressDialog.setCancelable(false);
progressDialog.show();
progressDialog.dismiss();

NB : Você deve substituir as atividadesonBackPressed()

Implementação do Java8:

@Override
public void onBackPressed() {
    progressDialog.onBackPressed(
            () -> {
                super.onBackPressed();
                return null;
            }
    );
}

Implementação Kotlin:

override fun onBackPressed() {
   progressDialog.onBackPressed { super.onBackPressed() }
}
Livin Mathew
fonte
1

Talvez este guia possa ajudá-lo.

Normalmente, prefiro criar AlertDialogs personalizados com indicadores. Resolve problemas como a personalização da visualização do aplicativo.

Dmitry Ushkevich
fonte
1

Pode ajudar a outras pessoas.

Muitos aplicativos populares têm uma abordagem diferente para mostrar o progresso de qualquer solicitação de rede, carregamento de arquivos etc. O carregamento do spinner não mostra a quantidade de conteúdo carregado ou restante a ser carregado. Há um período de incerteza que é ruim na perspectiva da UI / UX. Muitos aplicativos populares (Facebook, Linkedin etc.) resolveram esse problema, mostrando primeiro a interface do usuário básica. Em seguida, o conteúdo carregado é preenchido gradualmente na tela.

Eu usei o brilho nos meus aplicativos para resolver esse problema.

Existe um bom artigo sobre isso que será benéfico para outras pessoas

Rajesh Khadka
fonte
0

Na caixa de diálogo de progresso, o usuário não pode fazer nenhum tipo de trabalho. Todos os processos em segundo plano são interrompidos durante o diálogo de progresso. Portanto, é aconselhável usar a barra de progresso em vez da caixa de diálogo de progresso.

Nevil Ghelani
fonte