Java 无法在Android对话框中添加窗口

首先，用户输入用户名和密码，然后应用程序从API获取数据列表

当应用程序正在同步API中的数据时，我试图显示一个对话框，但出现以下错误：

日志：

ERROR

07-03 14:12:29.791  24439-24439/com.rep E/AndroidRuntime﹕ FATAL EXCEPTION: main
    android.view.WindowManager$BadTokenException: Unable to add window -- token null is not for an application
            at android.view.ViewRootImpl.setView(ViewRootImpl.java:571)
            at android.view.WindowManagerGlobal.addView(WindowManagerGlobal.java:246)
            at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:69)
            at android.app.Dialog.show(Dialog.java:281)
            at com.app.login.LoginActivity$SincronizarTask.(LoginActivity.java:292)
            at com.app.login.LoginActivity$AutenticacaoLocalTask.onPostExecute(LoginActivity.java:248)
            at com.app.login.LoginActivity$AutenticacaoLocalTask.onPostExecute(LoginActivity.java:163)
            at android.os.AsyncTask.finish(AsyncTask.java:631)
            at android.os.AsyncTask.access$600(AsyncTask.java:177)
            at android.os.AsyncTask$InternalHandler.handleMessage(AsyncTask.java:644)
            at android.os.Handler.dispatchMessage(Handler.java:99)
            at android.os.Looper.loop(Looper.java:137)
            at android.app.ActivityThread.main(ActivityThread.java:5226)
            at java.lang.reflect.Method.invokeNative(Native Method)
            at java.lang.reflect.Method.invoke(Method.java:511)
            at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:795)
            at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:562)
            at dalvik.system.NativeStart.main(Native Method)

同步类：

 public class SincronizarTask extends AsyncTask {

        private final ProgressDialog dialog;
        private Context ctx;
        private ProgressDialog mProgressDialog;
        private Sincronizar mSincronizar = new Sincronizar(this.ctx);

        public SincronizarTask(Context activity) {

            ctx = activity;
            mSincronizar = new Sincronizar(ctx);

            dialog = new ProgressDialog(ctx);
            dialog.setCancelable(false);
            dialog.setTitle("Sincronizando");
            dialog.setMessage("Aguarde...");

            if (!dialog.isShowing()) {
                dialog.show();
            }

        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            Log.i("RM", "onPreExecute");
        }

        @Override
        protected Boolean doInBackground(Void... params) {

            Log.i("RM", "doInBackground");

            try {
                ClientesRest mClientesRest = new ClientesRest(this.ctx);

                Log.i("RM", "doInBackground : P1");

                mClientesRest.getClientes(new ClientesRest.ClientesRestListener() {
                    public void clientesReceived(List clientes) {
                        Log.i("RM", "doInBackground : P:2");
                        Log.i("RM", String.valueOf(clientes));
                        Log.i("RM", "doInBackground : P:3");
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }

            return true;

        }

        @Override
        protected void onPostExecute(final Boolean success) {
            dialog.dismiss();
        }

        @Override
        protected void onCancelled() {
            mAutenticacaoLocalTask = null;
            dialog.dismiss();
        }

    }

ClientRest类：

import android.content.Context;
import android.util.Log;

import com.model.ClienteModel;
import com.webservice.Servidor;
import com.webservice.volley.AuthFailureError;
import com.webservice.volley.Request;
import com.webservice.volley.RequestQueue;
import com.webservice.volley.Response;
import com.webservice.volley.VolleyError;
import com.webservice.volley.toolbox.JsonObjectRequest;
import com.webservice.volley.toolbox.Volley;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static java.lang.String.valueOf;

public class ClientesRest extends Servidor {

    private String recursoRest = "clientes";

    private RequestQueue mRequestQueue;

    private Context context;

    public ClientesRest(Context ctx) {
        this.context = ctx;
    }

    public interface ClientesRestListener {
        public void clientesReceived(List<ClienteModel> clientes);
    }

    public final void getClientes(final ClientesRestListener listener) {

        String url = this.URL_WS + recursoRest;
        mRequestQueue = Volley.newRequestQueue(this.context);

        JsonObjectRequest mJsonObjectRequest = new JsonObjectRequest(Request.Method.GET, url, null, new Response.Listener<JSONObject>() {

            @Override
            public void onResponse(JSONObject response) {
                List<ClienteModel> clientes = null;
                try {
                    clientes = parseJSON(response);
                } catch (JSONException e) {
                    e.printStackTrace();
                   // Log.i("RM", String.valueOf(e.getStackTrace()));
                }
                listener.clientesReceived(clientes);
            }

        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                Log.i("RM", error.getMessage());
            }

        }
        ) {
            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap<String, String> headers = new HashMap<String, String>();
                headers.put("X--TOKEN", "xxxxxxxxxxxxxxxxxxxxxxxx");
                return headers;
            }
        };

        mRequestQueue.add(mJsonObjectRequest);
    }

    private List<ClienteModel> parseJSON(JSONObject json) throws JSONException {

        Log.i("RM", "executou o parseJSON");

            /* array para armazenar os clientes */
        ArrayList<ClienteModel> arrayClientes = new ArrayList<ClienteModel>();

            /* pega o array "dados" que vem na resposta da consulta ao rest */
        JSONArray dados = json.getJSONArray("dados");

            /* percorre o array */
        for (int i = 0; i < dados.length(); i++) {

                /* pega a posição de cada linha no array */
            JSONObject item = dados.getJSONObject(i);

                /* cria um objeto do tipo ClienteModel */
            ClienteModel mClienteModel = new ClienteModel();

                /* cadastra os dados necessários no objeto mClienteModel */
            mClienteModel.set_idrm(Integer.parseInt(item.optString("id")));
            mClienteModel.set_nome(item.optString("nome"));
            mClienteModel.set_tipo(item.getString("tipo"));
            mClienteModel.set_endereco(item.optString("endereco"));
            mClienteModel.set_numero(item.optString("numero"));
            mClienteModel.set_complemento(item.optString("complemento"));
            mClienteModel.set_cep(item.optString("cep"));
            mClienteModel.set_bairro(item.optString("bairro"));
            mClienteModel.set_cidade(item.optString("cidade"));
            mClienteModel.set_estado(item.optString("estado"));
            mClienteModel.set_informacao_adicional("informacao_adicional");

            /* adicionar o objeto mClienteModel no array de Clientes "arrayClientes" */
            arrayClientes.add(mClienteModel);
        }

        return arrayClientes;

    }
}

导入android.content.Context；
导入android.util.Log；
导入com.model.ClienteModel；
导入com.webservice.Servidor；
导入com.webservice.volley.AuthFailureError；
导入com.webservice.volley.Request；
导入com.webservice.volley.RequestQueue；
导入com.webservice.volley.Response；
导入com.webservice.volley.VolleyError；
导入com.webservice.volley.toolbox.JsonObjectRequest；
导入com.webservice.volley.toolbox.volley；
导入org.json.JSONArray；
导入org.json.JSONException；
导入org.json.JSONObject；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入静态java.lang.String.valueOf；
公共类客户列表扩展了Servidor{
私有字符串recursoRest=“clientes”；
私有请求队列mRequestQueue；
私人语境；
公共客户列表（上下文ctx）{
this.context=ctx；
}
公共接口客户端列表器{
收到的公共无效客户（列出客户）；
}
public final void getclients（final clientsrestlistener侦听器）{
字符串url=this.url\u WS+recursoRest；
mRequestQueue=Volley.newRequestQueue（this.context）；
JsonObjectRequest mJsonObjectRequest=新JsonObjectRequest（Request.Method.GET，url，null，new Response.Listener（））{
@凌驾
公共void onResponse（JSONObject响应）{
列出客户=空；
试一试{
clientes=parseJSON（响应）；
}捕获（JSONException e）{
e、 printStackTrace（）；
//Log.i（“RM”，String.valueOf（e.getStackTrace（））；
}
侦听器。客户已接收（客户）；
}
}，new Response.ErrorListener（）{
@凌驾
公共无效onErrorResponse（截击错误）{
Log.i（“RM”，error.getMessage（））；
}
}
) {
@凌驾
公共映射getHeaders（）引发AuthFailureError{
HashMap headers=新的HashMap（）；
headers.put（“X--令牌”，“xxxxxxxxxxxxxxxxxxxxxxxx”）；
返回标题；
}
};
mRequestQueue.add（mJsonObjectRequest）；
}
私有列表parseJSON（JSONObject json）抛出JSONException{
Log.i（“RM”、“executou o parseJSON”）；
/*armazenar os客户阵列*/
ArrayList ArrayClients=新的ArrayList（）；
/*pega o阵列“护墙板”可用于解决领事馆休息问题*/
JSONArray dados=json.getJSONArray（“dados”）；
/*percorre o阵列*/
对于（int i=0；i

private Sincronizar msincroniar=new Sincronizar（this.ctx）

换成

---

私有Sincronizar msincroniar

此任务是从活动还是从服务启动的？如果是一项活动，在生命周期中的什么时候调用它？是在调用onResume之前吗？我会在问题中添加一些代码，所以我假设Servidor是一项服务，基于我高中三年的西班牙语？如果是这样的话，这是意料之中的——一个服务没有用户界面，不能显示在屏幕上，只有很少的例外（我只知道键盘），你不能直接显示。您可以启动以对话框为主题的新活动。或者你可以使用通知或祝酒词。但是你不能直接从服务中弹出一个对话框。首先，为什么你要同时使用截击和异步任务？