AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android 中即时聊天或者后台任务需要发送消息的一种解决方案.

2015-11-20 1937
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 版权声明：本文为博主原创文章，未经博主允许不得转载。          在即时聊天中可能会存在一个隐藏的Bug,这个Bug根据手机的网速和性能有关系,比如你即时聊天中,你发送一消息,你的网络情况不是很好,这个时候你发送的消息一直处于发送状态,然后你不想看了,就按退出,这个时候Activity或者Fragment被销毁的时候就导致了这个消息被强行GC了,所以为了解决这个方

版权声明：本文为博主原创文章，未经博主允许不得转载。

    

    在即时聊天中可能会存在一个隐藏的Bug,这个Bug根据手机的网速和性能有关系,比如你即时聊天中,你发送一消息,你的网络情况不是很好,这个时候你发送的消息一直处于发送状态,然后你不想看了,就按退出,这个时候Activity或者Fragment被销毁的时候就导致了这个消息被强行GC了,所以为了解决这个方案,我们可以使用IntentService,什么是IntentService?

[java]  view plain copy
  1. /*IntentService is a base class for {@link Service}s that handle asynchronous  
  2. requests (expressed as {@link Intent}s) on demand. Clients send requests  
  3. through {@link android.content.Context#startService(Intent)} calls; the  
  4. service is started as needed, handles each Intent in turn using a worker  
  5. thread, and stops itself when it runs out of work.*/  


    从这个解释中可以看出来是一个异步服务,而且不用担心他自己的生命周期.所以我们就可以使用它去发送消息,当然消息发送完毕后,我们肯定要通知界面更新UI,这个时候我们就需要使用广播比较方便些.我们可以这样写一个IntentService:

[java]  view plain copy
  1. package com.softtanck.intentservicedemo.service;  
  2.   
  3. import android.app.IntentService;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6.   
  7. import com.softtanck.intentservicedemo.MainActivity;  
  8.   
  9. /** 
  10.  * Created by winterfell on 11/17/2015. 
  11.  */  
  12. public class UpLoadImgService extends IntentService {  
  13.   
  14.   
  15.     public UpLoadImgService() {  
  16.         super("ceshi");  
  17.     }  
  18.   
  19.     /** 
  20.      * Creates an IntentService.  Invoked by your subclass's constructor. 
  21.      * 
  22.      * @param name Used to name the worker thread, important only for debugging. 
  23.      */  
  24.     public UpLoadImgService(String name) {  
  25.         super(name);  
  26.     }  
  27.   
  28.   
  29.     public static void startUploadImg(Context context, String path) {  
  30.         Intent intent = new Intent(context, UpLoadImgService.class);  
  31.         intent.setAction(MainActivity.UPLOAD_IMG);  
  32.         intent.putExtra(MainActivity.EXTRA_IMG_PATH, path);  
  33.         context.startService(intent);  
  34.     }  
  35.   
  36.   
  37.     @Override  
  38.     protected void onHandleIntent(Intent intent) {  
  39.   
  40.         if (null != intent) {  
  41.             String action = intent.getAction();  
  42.   
  43.             if (action.equals(MainActivity.UPLOAD_IMG)) {  
  44.                 //UpLoad file  
  45.                 uploadImg(intent.getStringExtra(MainActivity.EXTRA_IMG_PATH));  
  46.             }  
  47.         }  
  48.   
  49.     }  
  50.   
  51.     private void uploadImg(String path) {  
  52.         try {  
  53.             Thread.sleep(2000);  
  54.             Intent intent = new Intent(MainActivity.UPLOAD_IMG);  
  55.             intent.putExtra(MainActivity.EXTRA_IMG_PATH, path);  
  56.             sendBroadcast(intent);  
  57.         } catch (InterruptedException e) {  
  58.             e.printStackTrace();  
  59.         }  
  60.     }  
  61. }  


    然后在需要的地方去调用:

[java]  view plain copy
  1. UpLoadImgService.startUploadImg(MainActivity.this, "/sdcard/cache/com.softtanck.intentservice/1.png");  



    还有就是IntentService是继承的Service,那么它是怎么实现异步线程的.?我们先粗略看一下它的源码:

[java]  view plain copy
  1. /* 
  2.  * Copyright (C) 2008 The Android Open Source Project 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package android.app;  
  18.   
  19. import android.annotation.WorkerThread;  
  20. import android.content.Intent;  
  21. import android.os.Handler;  
  22. import android.os.HandlerThread;  
  23. import android.os.IBinder;  
  24. import android.os.Looper;  
  25. import android.os.Message;  
  26.   
  27. /** 
  28.  * IntentService is a base class for {@link Service}s that handle asynchronous 
  29.  * requests (expressed as {@link Intent}s) on demand.  Clients send requests 
  30.  * through {@link android.content.Context#startService(Intent)} calls; the 
  31.  * service is started as needed, handles each Intent in turn using a worker 
  32.  * thread, and stops itself when it runs out of work. 
  33.  * 
  34.  * <p>This "work queue processor" pattern is commonly used to offload tasks 
  35.  * from an application's main thread.  The IntentService class exists to 
  36.  * simplify this pattern and take care of the mechanics.  To use it, extend 
  37.  * IntentService and implement {@link #onHandleIntent(Intent)}.  IntentService 
  38.  * will receive the Intents, launch a worker thread, and stop the service as 
  39.  * appropriate. 
  40.  * 
  41.  * <p>All requests are handled on a single worker thread -- they may take as 
  42.  * long as necessary (and will not block the application's main loop), but 
  43.  * only one request will be processed at a time. 
  44.  * 
  45.  * <div class="special reference"> 
  46.  * <h3>Developer Guides</h3> 
  47.  * <p>For a detailed discussion about how to create services, read the 
  48.  * <a href="{@docRoot}guide/topics/fundamentals/services.html">Services</a> developer guide.</p> 
  49.  * </div> 
  50.  * 
  51.  * @see android.os.AsyncTask 
  52.  */  
  53. public abstract class IntentService extends Service {  
  54.     private volatile Looper mServiceLooper;  
  55.     private volatile ServiceHandler mServiceHandler;  
  56.     private String mName;  
  57.     private boolean mRedelivery;  
  58.   
  59.     private final class ServiceHandler extends Handler {  
  60.         public ServiceHandler(Looper looper) {  
  61.             super(looper);  
  62.         }  
  63.   
  64.         @Override  
  65.         public void handleMessage(Message msg) {  
  66.             onHandleIntent((Intent)msg.obj);  
  67.             stopSelf(msg.arg1);  
  68.         }  
  69.     }  
  70.   
  71.     /** 
  72.      * Creates an IntentService.  Invoked by your subclass's constructor. 
  73.      * 
  74.      * @param name Used to name the worker thread, important only for debugging. 
  75.      */  
  76.     public IntentService(String name) {  
  77.         super();  
  78.         mName = name;  
  79.     }  
  80.   
  81.     /** 
  82.      * Sets intent redelivery preferences.  Usually called from the constructor 
  83.      * with your preferred semantics. 
  84.      * 
  85.      * <p>If enabled is true, 
  86.      * {@link #onStartCommand(Intent, int, int)} will return 
  87.      * {@link Service#START_REDELIVER_INTENT}, so if this process dies before 
  88.      * {@link #onHandleIntent(Intent)} returns, the process will be restarted 
  89.      * and the intent redelivered.  If multiple Intents have been sent, only 
  90.      * the most recent one is guaranteed to be redelivered. 
  91.      * 
  92.      * <p>If enabled is false (the default), 
  93.      * {@link #onStartCommand(Intent, int, int)} will return 
  94.      * {@link Service#START_NOT_STICKY}, and if the process dies, the Intent 
  95.      * dies along with it. 
  96.      */  
  97.     public void setIntentRedelivery(boolean enabled) {  
  98.         mRedelivery = enabled;  
  99.     }  
  100.   
  101.     @Override  
  102.     public void onCreate() {  
  103.         // TODO: It would be nice to have an option to hold a partial wakelock  
  104.         // during processing, and to have a static startService(Context, Intent)  
  105.         // method that would launch the service & hand off a wakelock.  
  106.   
  107.         super.onCreate();  
  108.         HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");//创建了一个HandlerThread  
  109.         thread.start();  
  110.   
  111.         mServiceLooper = thread.getLooper();  
  112.         mServiceHandler = new ServiceHandler(mServiceLooper);  
  113.     }  
  114.   
  115.     @Override  
  116.     public void onStart(Intent intent, int startId) {  
  117.         Message msg = mServiceHandler.obtainMessage();  
  118.         msg.arg1 = startId;  
  119.         msg.obj = intent;  
  120.         mServiceHandler.sendMessage(msg);  
  121.     }  
  122.   
  123.     /** 
  124.      * You should not override this method for your IntentService. Instead, 
  125.      * override {@link #onHandleIntent}, which the system calls when the IntentService 
  126.      * receives a start request. 
  127.      * @see android.app.Service#onStartCommand 
  128.      */  
  129.     @Override  
  130.     public int onStartCommand(Intent intent, int flags, int startId) {  
  131.         onStart(intent, startId);  
  132.         return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;  
  133.     }  
  134.   
  135.     @Override  
  136.     public void onDestroy() {  
  137.         mServiceLooper.quit();  
  138.     }  
  139.   
  140.     /** 
  141.      * Unless you provide binding for your service, you don't need to implement this 
  142.      * method, because the default implementation returns null.  
  143.      * @see android.app.Service#onBind 
  144.      */  
  145.     @Override  
  146.     public IBinder onBind(Intent intent) {  
  147.         return null;  
  148.     }  
  149.   
  150.     /** 
  151.      * This method is invoked on the worker thread with a request to process. 
  152.      * Only one Intent is processed at a time, but the processing happens on a 
  153.      * worker thread that runs independently from other application logic. 
  154.      * So, if this code takes a long time, it will hold up other requests to 
  155.      * the same IntentService, but it will not hold up anything else. 
  156.      * When all requests have been handled, the IntentService stops itself, 
  157.      * so you should not call {@link #stopSelf}. 
  158.      * 
  159.      * @param intent The value passed to {@link 
  160.      *               android.content.Context#startService(Intent)}. 
  161.      */  
  162.     @WorkerThread  
  163.     protected abstract void onHandleIntent(Intent intent);  
  164. }  


    从源码中可以看出在OnCreat的时候初始化了一个HandlerThread,然后通过Looper的Loop去从消息队列里面去,建立了Handler的通信,而HandlerMessage中调用一个抽象的方法就是我们继承IntentService中的要实现的方法,该方法就是在线程中的,所以不需要再去开启线程.它的生命周期也是由Service是管理的.

文章标签：
Android开发
Java
消息中间件
关键词：
Android解决方案
Android消息
恩恩123
目录
相关文章
是阿超
|
7月前
|
XML Android开发 数据格式
android点击FrameLayout、LinearLayout等父布局没响应的原因以及解决方案
android点击FrameLayout、LinearLayout等父布局没响应的原因以及解决方案
是阿超
195 2
一歲抬頭
|
7月前
|
安全 Shell Android开发
Android系统 init.rc sys/class系统节点写不进解决方案和原理分析
Android系统 init.rc sys/class系统节点写不进解决方案和原理分析
一歲抬頭
442 0
游客moiomvrp3vyac2
|
1月前
|
开发框架 前端开发 Android开发
探索安卓和iOS应用开发中的跨平台解决方案
【10月更文挑战第42天】在移动应用开发的广阔天地中，安卓和iOS系统如同两座巍峨的山峰，分别占据着半壁江山。开发者们在这两座山峰之间穿梭，努力寻找一种既能节省资源又能提高效率的跨平台开发方案。本文将带你走进跨平台开发的世界，探讨各种解决方案的优势与局限，并分享一些实用的代码示例，助你在应用开发的道路上更加游刃有余。
游客moiomvrp3vyac2
33 1
aliyun0641063962-48771
|
1月前
|
安全 搜索推荐 程序员
深入探索Android系统的碎片化问题及其解决方案
在移动操作系统的世界中，Android以其开放性和灵活性赢得了广泛的市场份额。然而，这种开放性也带来了一个众所周知的问题——系统碎片化。本文旨在探讨Android系统碎片化的现状、成因以及可能的解决方案，为开发者和用户提供一种全新的视角来理解这一现象。通过分析不同版本的Android系统分布、硬件多样性以及更新机制的影响，我们提出了一系列针对性的策略，旨在减少碎片化带来的影响，提升用户体验。
aliyun0641063962-48771
89 0
shuj
|
2月前
|
开发框架 移动开发 Android开发
安卓与iOS开发中的跨平台解决方案：Flutter入门
【9月更文挑战第30天】在移动应用开发的广阔舞台上，安卓和iOS两大操作系统各自占据半壁江山。开发者们常常面临着选择：是专注于单一平台深耕细作，还是寻找一种能够横跨两大系统的开发方案？Flutter，作为一种新兴的跨平台UI工具包，正以其现代、响应式的特点赢得开发者的青睐。本文将带你一探究竟，从Flutter的基础概念到实战应用，深入浅出地介绍这一技术的魅力所在。
shuj
99 7
天下无贼001
|
3月前
|
开发框架 前端开发 Android开发
安卓与iOS开发中的跨平台解决方案
【9月更文挑战第27天】在移动应用开发的广阔天地中，安卓和iOS两大操作系统如同双子星座般耀眼。开发者们在这两大平台上追逐着创新的梦想，却也面临着选择的难题。如何在保持高效的同时，实现跨平台的开发？本文将带你探索跨平台开发的魅力所在，揭示其背后的技术原理，并通过实际案例展示其应用场景。无论你是安卓的忠实拥趸，还是iOS的狂热粉丝，这篇文章都将为你打开一扇通往跨平台开发新世界的大门。
天下无贼001
82 8
Codelinghu
|
2月前
|
Android开发
Android开发显示头部Bar的需求解决方案--Android应用实战
Android开发显示头部Bar的需求解决方案--Android应用实战
Codelinghu
26 0
请看我回答~
|
4月前
|
前端开发 开发工具 Android开发
探索安卓与iOS应用开发：跨平台解决方案的崛起
【8月更文挑战第27天】在移动设备日益普及的今天，安卓和iOS系统占据了市场的主导地位。开发者们面临着一个重要问题：是选择专注于单一平台，还是寻找一种能够同时覆盖两大系统的解决方案？本文将探讨跨平台开发工具的优势，分析它们如何改变了移动应用的开发格局，并分享一些实用的开发技巧。无论你是新手还是资深开发者，这篇文章都将为你提供有价值的见解和建议。
请看我回答~
59 2
旺仔大牛
|
4月前
|
Android开发
Android编译出现Warning: Mapping new ns to old ns的解决方案
Android编译出现Warning: Mapping new ns to old ns的解决方案
旺仔大牛
417 3
游客qf4jmczx4xu2y
|
4月前
|
前端开发 JavaScript Android开发
探索Android和iOS开发中的跨平台解决方案
【8月更文挑战第1天】随着移动应用市场的不断扩张，开发者面临一个共同的挑战——如何高效地为多个平台创建和维护应用程序。本文将深入探讨跨平台开发工具，特别是Flutter和React Native，通过比较它们的优势和限制，并辅以实际代码示例，揭示这些工具如何帮助开发者在保持高性能的同时，实现代码的最大化重用。
游客qf4jmczx4xu2y
244 2