安卓设计 : Intentservice causing application not responding-6ren

安卓设计 : Intentservice causing application not responding

转载作者：行者123 更新时间：2023-11-29 02:20:55

我设计了一个导致应用程序没有响应的代码。

我已将 okhttp3.WebSocket 用于连续输入数据流，我决定在其上启动一个 IntentService，它将从服务器获取数据。
我有一个 IntentService；在 onHandleIntent 中，我发出了从服务器获取数据的服务调用(大约 3 次调用)。
对于服务调用，我使用 android 的 AsyncTask，其中我的 WebConnectionManger 类在不同的线程上运行。

在 websocket 中，我正在获取特定记录的详细信息，我将从服务调用中获取该记录的详细信息。对于 5-6 条这样的记录，我的应用程序运行良好，但如果记录达到 80-100 条，我的应用程序根本不响应，并且出现 ANR。

我为此使用简单的普通 TCP 请求。

任何人都可以告诉我实际问题是什么以及如何摆脱它吗？任何帮助表示赞赏。

我正在粘贴 WebSocket、AsyncTask(其余两个具有相同的实现)、WebConnectionManger 类和 IntentService 类的代码。

WebSocket.class

public class WebSocket {

public static boolean isConnected;
public static String TO_UPDATE = "toOrderUpdate";
@SuppressLint("StaticFieldLeak")
private static WebSocket _instance;
private static OkHttpClient client;
private static WebSocket webSocket = null;
private Context mContext;
private AppPreferences preferences;

private WebSocket() {
    client = new OkHttpClient();
}

public WebSocket(Context context) {
    client = new OkHttpClient();
    mContext = context;
    preferences = new AppPreferences(mContext);
    init(mContext);

}

public static WebSocket getInstance(Context mContext) {
    if (_instance == null) {
        _instance = new WebSocket(mContext);
    }
    return _instance;
}
public static void closeWebSocket() {
    if (isConnected) {
        webSocket.close(1001, LOGOUT);
        _instance = null;
        webSocket = null;
        isConnected = false;
    }
}

public void init(Context context) {
    if (webSocket == null) {
        preferences = new AppPreferences(context);
        Request request = new Request.Builder()
                .url(preferences.getWSUrl() + ":" + preferences.getWSPort() + "/" + preferences.getUserID())
                .build();
        WebSocketMessageListener messageListener = new WebSocketMessageListener();
        webSocket = client.newWebSocket(request, messageListener);
        isConnected = true;
    }
}

private class WebSocketMessageListener extends WebSocketListener {

    //  private static final int NORMAL_CLOSURE_STATUS = 1000;

    @Override
    public void onOpen(WebSocket webSocket, Response response) {
        super.onOpen(webSocket, response);
        Log.i("******", "Socket Open");
    }

    @Override
    public void onMessage(WebSocket webSocket, String response) {
        try {
            super.onMessage(webSocket, response);
            Log.i("******", "Message Received " + response);
            // Logger.log("OnMessage : " + response);
            ModelAdvertisements modelAdvertisements = DecoderJSONWebSocket.decode(response);

            Intent intentForService = new Intent(mContext, WebSocketService.class);
            int transCode = Integer.parseInt(modelAdvertisements.getTC());
            Intent mwBroadcastIntent = new Intent();
            switch (transCode) {
                case 1005: 
                    mwBroadcastIntent.setAction(Constants.IntentKeys.KEY_LOGICAL_SESSION_START_END);
                    mContext.sendBroadcast(mwBroadcastIntent);
                    break;
                case 1004:
                case 1006:
                case 1007:
                        intentForService.putExtra(TO_UPDATE, true);
                        mContext.startService(intentForService);
                    break;
                case 1008:
                    try {
                        mwBroadcastIntent.putExtra(KEY_AUCTION_FLOOR_SNAPSHOT, modelAdvertisements);
                        mwBroadcastIntent.setAction(Constants.IntentKeys.KEY_MARKET_DATASNAPSHOT);
                        mContext.sendBroadcast(mwBroadcastIntent);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
            }
        } catch (Exception e) {
            // e.printStackTrace();
        }
    }

    @Override
    public void onClosing(WebSocket webSockett, int code, String reason) {
        super.onClosing(webSockett, code, reason);
        Log.i("******", "Socket Closing Reason: " + reason);
    }

    @Override
    public void onClosed(WebSocket webSockett, int code, String reason) {
        super.onClosed(webSockett, code, reason);
        Log.i("******", "Socket closed reason: " + reason);
        webSocket = null;
        isConnected = false;
    }

    @Override
    public void onFailure(WebSocket webSockett, Throwable t, Response response) {
        super.onFailure(webSockett, t, response);

            isConnected = false;
            webSocket = null;
            Logger.log(e);
    }
}
}

WebSocketService.class

public class WebSocketService extends IntentService {

String securityId;
private Context mContext;
private String tokenId;
private String contractCode;
private int transCode;
private boolean toUpdate;
private String mktCode;

public WebSocketService() {
    super("WebSocketService");
}

public WebSocketService(String name) {
    super(name);
}

@Override
protected void onHandleIntent(@Nullable Intent intent) {
    if (intent != null) {
        tokenId = intent.getStringExtra(KEY_TOKEN_ID);
        transCode = intent.getIntExtra(KEY_TRANSCODE, 0);
        toUpdate = intent.getBooleanExtra(NeMLWebSocket.TO_UPDATE, false);
        contractCode = intent.getStringExtra(KEY_SYMBOL);
        mktCode = intent.getStringExtra(KEY_ADV_REF_ID);
    }
    securityId = DatabaseUtils.getSecurityIdFromFOOrders(mContext, tokenId);

    performTokenMasterTask();

}

@Override
public void onCreate() {
    super.onCreate();
    mContext = this;
}

@Override
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
    return super.onStartCommand(intent, flags, startId);
}

protected void performTokenMasterTask() {

    synchronized (this) {



            TokenMasterTask tokenMasterTask = new TokenMasterTask(mContext, new RequestCallback() {

                @Override
                public void onStart() {
                }

                @Override
                public void onComplete(Object object) {
                    if (transCode == TC_1004_WEB_SOCKET) {
                        Intent mwBroadcastIntent = new Intent();
                        mwBroadcastIntent.setAction(Constants.IntentKeys.KEY_TOKEN_SESSION_START_END);
                        mContext.sendBroadcast(mwBroadcastIntent);
                        // stopSelf();
                    } else if (transCode == TC_TIME_WEB_SOCKET || transCode == TC_AUCTION_WEB_SOCKET) {
                        performTimeSessionTask();
                    }
                }

                @Override
                public void onProgress(int current, int total) {

                }

                @Override
                public void onError(int transCode, String msg) {
                    try {
                        Logger.log(transCode + "--->" + msg);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }, mktCode);
            tokenMasterTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, tokenId);
         if (transCode == TC_TIME_WEB_SOCKET || transCode == TC_AUCTION_WEB_SOCKET) {
            performTimeSessionTask();

        }
    }
}

public void performTimeSessionTask() {
    synchronized (this) {

            TimeSessionMapTask timeSessionMapTask = new TimeSessionMapTask(mContext, new RequestCallback() {

                ProgressDialog progressDialog;
                private boolean m_ConnectionErr = false;

                @Override
                public void onStart() {

                }

                @Override
                public void onComplete(Object object) {

                    if (!m_ConnectionErr) {
                        if (transCode == TC_AUCTION_WEB_SOCKET) {
                            performFoOrderTask();
                        }
                    }
                }

                @Override
                public void onProgress(int current, int total) {

                }

                @Override
                public void onError(int transCode, String msg) {
                    try {
                        Logger.log("Received ErrorMessage :" + msg + " \n ErrorCode :" + transCode);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }, modelMarket);

            timeSessionMapTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, TIME_SESSION);
        if (transCode == TC_AUCTION_WEB_SOCKET) {
            performFoOrderTask();
        }
    }
}

private synchronized void performFoOrderTask() {

    synchronized (mContext) {

            FOOrdersTask foOrdersTask = new FOOrdersTask(mContext, new RequestCallback() {


                @Override
                public void onStart() {

                }

                @Override
                public void onComplete(Object object) {
               }

                @Override
                public void onProgress(int current, int total) {
                }

                @Override
                public void onError(int transCode, String msg) {

                }
            });

            foOrdersTask.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR, tokenId);

    }
}

}

TokenMasterTask.class

public class TokenMasterTask extends AsyncTask<Object, Void, ModelToken> {

private final String mktCode;
private RequestCallback _callback;
@SuppressLint("StaticFieldLeak")
private Context context;
private boolean isConnectionError;
private ModelToken modelToken;
private boolean isServerDown;

public TokenMasterTask(Context context, RequestCallback requestCallback, String mktCode) {
    this.context = context;
    this.mktCode = mktCode;
    if (requestCallback == null) {
        requestCallback = new RequestCallback() {
            @Override
            public void onStart() {

            }

            @Override
            public void onComplete(Object object) {

            }

            @Override
            public void onProgress(int current, int total) {

            }

            @Override
            public void onError(int transCode, String msg) {

            }
        };
    }
    this._callback = requestCallback;
}

@Override
protected ModelToken doInBackground(Object... voids) {
    if (voids != null && voids.length > 0) {
        String tokenId = String.valueOf(voids[0]);
        isConnectionError = false;
        transactionCall(tokenId);
    }
    return modelToken;
}

private void transactionCall(String tokenId) {
    try {
        WebConnectionManager connectionManager = new WebConnectionManager(context, new ConnectionListener() {
            @Override
            public void notifyReadCompleted(String f_Response) {
                modelToken = DecoderTokenRequest.decode(f_Response);
                synchronized (TokenMasterTask.this) {
                    TokenMasterTask.this.notify();
                }
            }

            @Override
            public void notifySocketError(boolean isServerDown) {
                if (!isServerDown) {
                    isConnectionError = true;
                }
                TokenMasterTask.this.isServerDown = isServerDown;
                synchronized (TokenMasterTask.this) {
                    TokenMasterTask.this.notify();
                }
            }

            @Override
            public void onReceivePacket(int total, int current) {
                _callback.onProgress(current, total);
            }
        });
        connectionManager.modifiedHandleRequest(EncoderTokenRequest.encode(context, tokenId,mktCode).getBytes());
    } catch (Exception e) {
        e.printStackTrace();
        Logger.log(e);
    }
    synchronized( TokenMasterTask.this) {
        try {
            TokenMasterTask.this.wait();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

@Override
protected void onPostExecute(ModelToken modelToken) {

    if (isServerDown) {
        _callback.onError(Constants.ErrorCode.TC_ERROR_SERVER_DOWN, "");
    } else if (isConnectionError) {
        _callback.onError(0, "Connection Error.");

    } else if (modelToken!=null && modelToken.getErrorCode() != null && !TextUtils.isEmpty(modelToken.getErrorCode()) && !modelToken.getErrorCode().equalsIgnoreCase("200")) {
        _callback.onError(Integer.parseInt(modelToken.getErrorCode()), modelToken.getError());

    } else {
        _callback.onComplete(modelToken);
    }
    super.onPostExecute(modelToken);
}
}

WebConnectionManager.class

public class WebConnectionManager {

private String m_Response = "";
byte[] m_RequestData;
boolean m_Read_Response_Completed = false;
Thread l_WorkerThread;
ConnectionListener m_ConnectionListener;
boolean m_IsFetchCompleted;
Context context;
AppPreferences preferences;
Socket mWebSocket;


public WebConnectionManager(Context mcontext, ConnectionListener f_LoginListener) {
    m_ConnectionListener = f_LoginListener;
    m_IsFetchCompleted = false;
    context = mcontext;
    preferences = new AppPreferences(context);

}

public String modifiedHandleRequest(byte[] f_RequestData) {
    m_RequestData = f_RequestData;
    Logger.log("" + Constants.TIME_OUT);
    l_WorkerThread = new Thread(new Runnable() {
        @Override
        public void run() {
            String encodedIP = null;

            try {

                if (mWebSocket == null || !mWebSocket.isBound()
                        || mWebSocket.isClosed() ) {
                    mWebSocket = new Socket(ip, port);
                    mWebSocket.setKeepAlive(true);
                    mWebSocket.setSoTimeout(Constants.TIME_OUT);

                }

                if (m_RequestData == null) {
                    m_Read_Response_Completed = true;
                    if (!mWebSocket.isClosed()) {
                        m_ConnectionListener.notifyReadCompleted("Connected");
                        return;
                    } else {
                        m_ConnectionListener.notifyReadCompleted("Disconnected");
                        return;
                    }
                } else {
                    String request = new String(m_RequestData);
                    Logger.log(Utils.encodePackets(request));
                }

                InputStream inputStream = mWebSocket.getInputStream();
                try {
                    mWebSocket.getOutputStream().write(m_RequestData);
                } catch (Exception e) {
                    Logger.log(e);
                }

                ByteArrayOutputStream byteArrayOutputStream =
                        new ByteArrayOutputStream(1048576);
                byte[] buffer = new byte[1048576];


                int bytesRead = 0;
                while ((bytesRead = inputStream.read(buffer)) != -1) {
                    byteArrayOutputStream.write(buffer, 0, bytesRead);
                    m_Response = byteArrayOutputStream.toString();
                }
                inputStream.close();
                byteArrayOutputStream.close();
                mWebSocket.close();
                if (TextUtils.isEmpty(m_Response.toString().trim())) {
                    throw new IOException("Empty Response");
                } else {
                    m_ConnectionListener.notifyReadCompleted(m_Response.toString());
                }

            } catch (UnknownHostException e) {
                Logger.log(e);
                m_ConnectionListener.notifySocketError(true);
                mWebSocket = null;
            } catch (SocketTimeoutException e) {
                Logger.log(e);
                m_ConnectionListener.notifySocketError(false);
                mWebSocket = null;
                e.printStackTrace();
            } catch (SocketException e) {
                Logger.log(e);
                m_ConnectionListener.notifySocketError(true);
                mWebSocket = null;
                e.printStackTrace();
            } catch (IOException e) {
                Logger.log(e);
                m_ConnectionListener.notifySocketError(true);
                mWebSocket = null;
                e.printStackTrace();
            } catch (Exception e) {
                Logger.log(e);
                m_ConnectionListener.notifySocketError(true);
                mWebSocket = null;
                e.printStackTrace();
            }
        }

    });
    l_WorkerThread.start();
    return m_Response;
}
}

还有接口(interface)。

public interface ConnectionListener {

void notifyReadCompleted(String f_Response);
void notifySocketError(boolean isServerDown);
void onReceivePacket(int total, int current);
}


public interface RequestCallback {

void onStart();

void onComplete(Object object);

void onProgress(int current, int total);

void onError(int transCode, String msg);
}

最佳答案

您可能想检查是什么阻塞了主线程超过 6 秒。

ANR 通常发生在主线程阻塞一段时间后。 6-10 秒。

关于安卓设计 : Intentservice causing application not responding，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55743886/

文章推荐： php - 每个元素添加数据库 "sub-table"

文章推荐： android - 我可以在 MPAndroidChart 中扩展 PieChart 吗？

文章推荐： ios - 在两个按钮之间居中 View

安卓 EditText 安卓 :textDirection
我想将 EditText 始终设置为 LTR，我该怎么做？android:textDirection 似乎确实是答案，我无法让项目使用该指令进行编译最佳答案为 editText 使用引力 andr
安卓 AppWidget + 安卓 :clearTaskOnLaunch ="true"
我希望我的应用在每次打开时都显示登录屏幕。使用 android:clearTaskOnLaunch="true" 一切正常。但是有一个错误，只有在手机关机并且应用程序首先使用小部件启动时才会发生。 I
Android WebView 从内部存储加载 |安卓 11 |安卓
实际上我的要求是我想将动态文件加载到像图像一样的网页中。视频，音频等，它来自 Assets 或应用程序自己的文件目录，这不是问题。我尝试使用以下两种方式。方式一这是我的 html 文件在 ass
安卓 DatePickerDialog API 23 (安卓 6)
我正在触发一个 DatePickerDialog，在 api 22 (Android 5.1) 之前它一直在工作并显示良好，我在上面设置混合和最大日期(最小 = 当前日期，最大 = 从当前日期开始的
安卓 : How to avoid header from scrolling in listview , 安卓？
我有一个 ListView ，我在其中将标题 View 添加到该列表。一切都很好，但是当滚动列表 headerview 也随着列表移动时，所以我想避免 headerview 滚动，我的意思是当我列表到
安卓 - 安卓 2.1 上的 SDK 4.0
虽然我在android上做过一些app，但我还是一头雾水。是否可以使用 SDK 4.0 中的功能，并在 android 2.1 或更低版本上运行该应用程序？我尝试了你们提到的方法，但出现错误 - F
安卓 GridView 安卓 :numColumns ="auto_fit" always create only two columns
您好，我正在开发小型 android 应用程序，我想在其中显示带有一些元素的简单 gridview。它工作正常。唯一的问题是即使有空间，它也总是只显示两列。它平均将屏幕分成 2 列并仅显示两个元素。如
安卓 2.3.3 & 4.1.2 安卓 :configChanges for detecting Orientation change
我正在使用 Android 2.3.3 API 构建一个应用程序。我需要识别方向的变化并执行一些操作。所以我在 Android Manifest 中添加了以下内容， android:configCha
安卓 NFC : can we use intent filter with mime type? (安卓 2.3.3)
我正在尝试在“点击”包含特定 MIME 类型的 nfc 标签时开始一项 Activity 。我制作了一个 mime 类型为“text/plain”的标签，并将其添加到 list 中:
安卓。将文件保存到设备上的共享目录中
我可以将一些数据保存到文件中 val byteArrayOutputStream = ByteArrayOutputStream() byteArrayOutputStream.wri
安卓:阿拉伯语字体
我正在尝试解析一个包含复杂阿拉伯字母的 XML 文件.. 当我在 android 2.3.7 上测试时，并不是所有的阿拉伯字母都被支持，仍然有一些复杂的显示为方 block .. 但是在 androi
安卓。确定设备是否为平板电脑的最佳方法是什么？
我需要编写一个方法来确定设备是平板电脑还是手机。我不需要根据这个显示不同的用户界面。我只需要有关设备的信息，以便将来我可以将其发送到指标。在互联网上，我找到了很多方法来确定设备是否是平板电脑。我已经
安卓，文字转语音
我正在玩文字转语音，让我的测试应用程序更有趣。它适用于模拟器，但不适用于我的手机，因为我的默认语言环境不是英语。但是，文本是英文的，所以 tts 当然应该使用英文。据我所知，我可以实现一个自动安装，
安卓。如何使用整洁架构的分页？
我正在使用 MVVM 和整洁的架构编写应用程序。在其中一个屏幕上，我需要使用 pagination 实现 RecyclerView。我将使用库 Paging3。 Android 开发者推荐在存储库层使
安卓。遗失证书如何找回
这个问题在这里已经有了答案: I lost my .keystore file? (12 个回答) 4年前关闭。当我以前的操作系统损坏并安装新的(7 月 3 日)时，以前的 android_key_
安卓。如何使用整洁架构的分页？
我正在使用 MVVM 和整洁的架构编写应用程序。在其中一个屏幕上，我需要使用 pagination 实现 RecyclerView。我将使用库 Paging3。 Android 开发者推荐在存储库层使
安卓|在导航栏上添加行
在我的 v27\style.xml 中，我有以下代码来设置白色导航栏: @color/colorPrimary @color/colorPrimaryDark @color/
安卓。发送多附件电子邮件
我想通过发送电子邮件 startActivity(Intent.createChooser(new Intent(android.content.Intent.ACTION_SEND))) 我知道要将
安卓:自定义列表适配器
我实现了一个自定义 ListView ，它看起来像 Twitter 时间线。 adapter = new MyClickableListAdapter(this, R.layout.timeline,
安卓;带有自定义对话框的进度条
我有一个显示启动画面的自定义对话框； mSplashDialog = new Dialog(MyActivity.this,R.layout.splash); mSplashDialog.setCon

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

安卓设计 : Intentservice causing application not responding