Service和Activity通讯的3种常用方式示例

最新推荐文章于 2021-05-27 09:48:21 发布
最新推荐文章于 2021-05-27 09:48:21 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： android 文章标签： android service回调Activity AIDL Handler bindService
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/banking17173/article/details/22093823
版权

一般的Android业务开发中，Service的使用十分常见。稍微复杂点的业务逻辑，都需要Serivice在执行某些耗时操作后通知Activity。总结常见的三种方法。

        分别是：（1）binder持有Activity的Handler对象，或者持有一个Activity的callbackInterface.

        （2）AIDL实现，完美支持IPC。

          （3）startService+broadcastReceiver实现。

          另外还有几种不推荐的方式，都有很高的局限性。比如Service执行后的结果持久化，通过startActivity在目标Activity中的OnNewIntent()处理（需要Activity是单例的)。

         （1）Binder持有Activity的Handler，这里推荐Handler弱引用Activity实现。

           关键代码如下：           

public class WeakReferenceHandlerActivity extends Activity {
	private MyHandler mHandler;
	public static int FLAG = 10;
	public ProgressBar progressBar;
	private Button bindButton;
	private Button nextButton;
	private UseHandlerService.MyBinder myBinder;  
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.handler_layout);
		progressBar = (ProgressBar)this.findViewById(R.id.progress);
		bindButton = (Button)this.findViewById(R.id.bind);
		nextButton = (Button)this.findViewById(R.id.next);
		mHandler = new MyHandler(this);
		
		bindButton.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				bindService();
				Log.d("","startDownLoad() --> click");
			}
		});
		nextButton.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				startActivity(new Intent(WeakReferenceHandlerActivity.this,AndroidAidlActivity.class));
			}
		});
	}

	
	  
    private ServiceConnection connection = new ServiceConnection() {  
  
        @Override  
        public void onServiceDisconnected(ComponentName name) {  
        	
        }  
  
        @Override  
        public void onServiceConnected(ComponentName name, IBinder service) { 
        	Log.d("","startDownLoad() --> onbind");
            myBinder = (UseHandlerService.MyBinder) service;  
            myBinder.setCallBackHandler(mHandler);
            myBinder.startDownLoad();
            
        }  
    };  
	
    @Override
	protected void onResume() {
    	
		super.onResume();
	}
    
    @Override
	protected void onPause() {
    	unBindService();
		super.onPause();
	}
    
    public void bindService(){
    	Intent bindIntent = new Intent(this, UseHandlerService.class);  
        bindService(bindIntent, connection, BIND_AUTO_CREATE);  
    }
    
    public void unBindService(){
    	unbindService(connection);
    }
    
	@Override
	protected void onDestroy() {
		// Remove all Runnable and Message.
		mHandler.removeCallbacksAndMessages(null);

		super.onDestroy();
	}

	public MyHandler getHandler(){
		return mHandler;
	}
	
	public class MyHandler extends Handler {
		// WeakReference to the outer class's instance.
		private WeakReference<WeakReferenceHandlerActivity> mOuter;

		public MyHandler(WeakReferenceHandlerActivity activity) {
			mOuter = new WeakReference<WeakReferenceHandlerActivity>(activity);
		}

		@Override
		public void handleMessage(Message msg) {
			WeakReferenceHandlerActivity outer = mOuter.get();
			if (outer != null) {
				// Do something with outer as your wish.
				if(!outer.isFinishing()){
					int progress = msg.what;
					progressBar.setProgress(progress);
				}
			}
		}
	}
}

public class UseHandlerService extends Service{
	/**
	 * 进度条的最大值
	 */
	public static final int MAX_PROGRESS = 100; 
	/**
	 * 进度条的进度值
	 */
	private int progress = 0;
	/**
	 * 更新进度的回调接口
	 */
	private MyHandler myHandler;
	private MyBinder mBinder = new MyBinder();  
	private String TAG = "UseHandlerService";
	/**
	 * 注册回调接口的方法，供外部调用
	 * @param onProgressListener
	 */
	public void setHandler(MyHandler handler) {
		myHandler = handler;
	}
	/**
	 * 增加get()方法，供Activity调用
	 * @return 下载进度
	 */
	public int getProgress() {
		return progress;
	}
	@Override  
    public void onCreate() {  
        super.onCreate();  
        Log.d(TAG, "onCreate() executed");  
    }  
  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
        Log.d(TAG, "onStartCommand() executed");  
        return super.onStartCommand(intent, flags, startId);  
    }  
  
    @Override  
    public void onDestroy() {  
        super.onDestroy();  
        Log.d(TAG, "onDestroy() executed");  
    }  

	/**
	 * 返回一个Binder对象
	 */
	@Override
	public IBinder onBind(Intent intent) {
		return mBinder;
	}
	
	public class MyBinder extends Binder{
		/**
		 * 获取当前Service的实例
		 * @return
		 */
		public UseHandlerService getService(){
			return UseHandlerService.this;
		}
		
		public void setCallBackHandler(MyHandler handler){
			myHandler = handler;
		}
		
		public void startDownLoad(){
			Log.d("","startDownLoad() inBinder-->");
			new Thread(new Runnable() {
				public void run() {
					while(progress < MAX_PROGRESS){
						progress += 5;
						Log.d("","startDownLoad() run-->");
						//进度发生变化通知调用方
						if(myHandler != null){
							myHandler.sendEmptyMessage(progress);
						}
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
			}).start();
		}
	}
}
弱引用的实现，是出于防止Service不销毁，一直导致目标Activity也不能会回收的考虑。



（2）AIDL实现，同样还是进度条的UI更新。

public class AndroidAidlActivity extends Activity {
    /** Called when the activity is first created. */
	public static final int MAX_PROGRESS = 100; 
	/**
	 * 进度条的进度值
	 */
	private int progress = 0;
	public ProgressBar progressBar;
	private Button bindButton;

	private MyAIDLService mService;
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.handler_layout);
        
        progressBar = (ProgressBar)this.findViewById(R.id.progress);
        bindButton = (Button)this.findViewById(R.id.bind);
		bindButton.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				bindService();
				Log.d("","startDownLoad() --> click");
			}
		});
		this.findViewById(R.id.next).setVisibility(View.GONE);
    }
    
    private ICallBack.Stub mCallback = new ICallBack.Stub() {
    	 
         @Override
         public void showResult(final int result) {
             Log.d("", "showresult -->" + result);
             progressBar.setProgress(result);
         }
    };
    
    private ServiceConnection connection = new ServiceConnection() {  
        @Override  
        public void onServiceDisconnected(ComponentName name) {  
        	mService = null;
        }  
        @Override  
        public void onServiceConnected(ComponentName name, IBinder service) { 
        	Log.d("","startDownLoad() --> onbind");
        	mService = MyAIDLService.Stub.asInterface(service);
        	try {
        	    mService.registerCallback(mCallback);
        	    mService.startDownload();
        	} catch (RemoteException e) {
        	    Log.e("", "", e);
        	}
            
        }  
    };  
	
    @Override
	protected void onResume() {
		super.onResume();
	}
    
    @Override
	protected void onPause() {
    	unBindService();
		super.onPause();
	}
    
    public void bindService(){
    	Intent bindIntent = new Intent(this, AidlService.class);  
        bindService(bindIntent, connection, BIND_AUTO_CREATE);  
    }
    
    public void unBindService(){
    	unbindService(connection);
    }
    
	@Override
	protected void onDestroy() {
		// Remove all Runnable and Message.
		super.onDestroy();
	}
	

}
public class AidlService extends Service {

	private RemoteCallbackList<ICallBack> mCallbacks = new RemoteCallbackList<ICallBack>();
	
		MyAIDLService.Stub mBinder = new Stub() {

			@Override
			public void registerCallback(ICallBack cb) throws RemoteException {
				if(cb != null) {
                    mCallbacks.register(cb);
				}
			}
			@Override
			public void unregisterCallback(ICallBack cb) throws RemoteException {
				if(cb != null) {
                    mCallbacks.unregister(cb);
				}
			}

			@Override
			public void startDownload() throws RemoteException {
				Log.d("","startDownLoad() inBinder-->");
				new Thread(new Runnable() {

					public void run() {
						while(progress < MAX_PROGRESS){
							progress += 5;
							Log.d("","startDownLoad() run-->");
							//进度发生变化通知调用方
							if(mHandler != null){
								//TODO
								mHandler.sendEmptyMessage(progress);
							}
							
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
						
					}
				}).start();
			}
		};
		/**
		 * 进度条的最大值
		 */
		public static final int MAX_PROGRESS = 100; 
		/**
		 * 进度条的进度值
		 */
		private int progress = 0;
		/**
		 * 更新进度的回调接口
		 */
		private String TAG = "UseHandlerService";
		/**
		 * 增加get()方法，供Activity调用
		 * @return 下载进度
		 */
		public int getProgress() {
			return progress;
		}

		@Override  
	    public void onCreate() {  
	        super.onCreate();  
	        //mHandler.sendEmptyMessageDelayed(0, 1000);
	        Log.d(TAG, "onCreate() executed");  
	    }  
		private void callBack(Message msg) {
			int N = mCallbacks.beginBroadcast();
			try {
			    for (int i = 0; i < N; i++) {
			    	Log.d("","mCallbacks -->progress"+msg.what);
			        mCallbacks.getBroadcastItem(i).showResult(msg.what);
			    }
			} catch (RemoteException e) {
			      Log.e(TAG, "", e);
			}
			mCallbacks.finishBroadcast();
		}
			
		private Handler mHandler = new Handler() {
			 
			      @Override
			      public void handleMessage(Message msg) {
			           callBack(msg);
			           super.handleMessage(msg);
			      }
			};
	    @Override  
	    public int onStartCommand(Intent intent, int flags, int startId) {  
	        Log.d(TAG, "onStartCommand() executed");  
	        return super.onStartCommand(intent, flags, startId);  
	    }  
	  
	    @Override  
	    public void onDestroy() {  
	        super.onDestroy();  
	        Log.d(TAG, "onDestroy() executed");  
	    }  
		/**
		 * 返回一个Binder对象
		 */
		@Override
		public IBinder onBind(Intent intent) {
			return mBinder;
		}
		

	}
还有两个AIDL文件
package com.banking.hello;

interface ICallBack {
    void showResult(int result);
} 

package com.banking.hello;
import com.banking.hello.ICallBack;
interface MyAIDLService {
	void registerCallback(ICallBack cb);
    void unregisterCallback(ICallBack cb);
    void startDownload();
}
这种方式，无论Service是否是remote，都可以实现高效率通讯。

（3）第三种通过Receiver非常简单，就不上代码了。
sendBroadCast,然后在Activity中注册一个相对应的内部receiver接受就可以了.

查看工程










                

        

        

    

  


    

      

        

            

              
                
                  bankingA
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Android开发入门：基础知识、编程模型、开发流程、组件和系统特性等

				
			

			

				

					程序员光剑
				

				

					08-07
					
					1603
					
				

			

		

		

			
				
Android（安卓）是一个开源的移动设备操作系统，由Google主导，是一种基于Linux的手机操作系统，最初叫做Harmony OS。目前市面上主要的版本包括Nexus、Pixel、Samsung Galaxy系列、HTC One系列、MIUI等，它已广泛应用于智能手机、平板电脑、路由器等多种终端设备上。2017年，谷歌推出了基于安卓源码的AOSP (Android Open Source Project)项目，Android系统源代码成为一个开放的社区可以供开发者进行修改和定制。

			
		

	



                

              
                



	

		

			

				
					
Android 跨进程通信 介绍（原理、IPC 重要性和应用场景、IPC 的主要方式详解以及选择 IPC 方式的考虑因素）

					
最新发布

				
			

			

				

					半夏微凉科技
				

				

					05-31
					
					189
					
				

			

		

		

			
				
跨进程通信（Inter-Process Communication，IPC）是在 Android 平台上实现不同应用程序或同一应用程序不同进程之间进行数据交换和通信的重要机制。Android 提供了多种 IPC 方式，每种方式都有其特定的优缺点，开发者需要根据应用场景和需求选择合适的方式。

			
		

	



                


  
              

                


	

		

			

				
					
利用Handler实现Activity和Service之间通信

				
			

			

				

					chao_shen的博客
				

				

					11-15
					
					2818
					
				

			

		

		

			
				
Activity和Service之前通信，最简单的方式就是通过broadcast广播来实现，但针对一些频繁的数据传输，用广播来实现，性能上会降低很多，例如：更新下载进度等


接下来介绍下handler来代替broadcast来实现Activity和Service之前通信，这样性能会高些。


中心思想是讲Handler包装在Messenger对象里，利用Messenger来发送消息，

			
		

	





	

		

			

				
					
（一）service和activity通信方式

				
			

			

				

					cf8833的博客
				

				

					11-13
					
					1738
					
				

			

		

		

			
				
实现效果图：



使用service在后台播放音乐，拖动进度条，与服务进行交互，改变音乐的播放进度

（1）首先，我们需要申请读取本地文件的权限，播放本机的音乐


  &lt;uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/&gt;
    &lt;uses-permission android:...

			
		

	



		

			
		



	

		

			

				
					
Handler实现Service和Activity通信（比广播更有性能上的优势，广播使用起来比较方便看个人爱好）

				
			

			

				

					coyote
				

				

					08-11
					
					405
					
				

			

		

		

			
				
Handler实现Service和Activity通信
1、使用Messenger实现跨进程通信
2、Messenger包含handler的引用
实现步骤（有点绕不要急）
1、在Service中创建Messenger包含handler引用
2、在onBind()方法中返回Messenger
3、Activity绑定Service，获得Service的Messenger
4、Activity中创建M...

			
		

	





	

		

			

				
					
Activity和Service之间通过handler传递数据

				
			

			

				

					stulcc的博客
				

				

					03-03
					
					1万+
					
				

			

		

		

			
				
在写音乐播放器的时候用到了这个东西，相当于Activity中把mHandler用Messenger这个信封包裹着传递到了到了Service。Service拿到这个信封，信封里面装着mHandler，告诉service往里面装信息，然后信封再邮寄给mHandler。
Activity中的主要代码：
1.开启我的服务的方法
	private void startMyService(String

			
		

	





	

		

			

				
					
Handler内存溢出解决方案

				
			

			

				

					charles_lun专栏
				

				

					02-25
					
					1878
					
				

			

		

		

			
				
Handler引起内存溢出，解决方案1.介绍public class SampleActivity extends Activity {
    private final Handler mLeakyHandler = new Handler() {
     @Override
     public void handleMessage(Message msg) {
    // ...

			
		

	





	

		

			

				
					
Android 解决Handler在运行时加载报空指针异常

				
			

			

				

					cll3966的博客
				

				

					07-31
					
					2904
					
				

			

		

		

			
				
1.可自定义一个这样的WeakReferenceHandlerpublic class WeakReferenceHandlerT> extends Handler {

    private final WeakReferenceT> mReference;

    public WeakReferenceHandler(T referencedObject) {
        mRefe

			
		

	





	

		

			

				
					
android高仿QQ的即时通讯附带服务端.zip

				
			

			

				

					07-13
				

			

		

		

			
				
1. **即时通讯技术**: 即时通讯（Instant Messaging, IM）是一种实时通信技术，用户可以立即发送和接收消息。在Android平台上实现即时通讯，通常会涉及到Socket编程、XMPP（Extensible Messaging and Presence ...

			
		

	





	

		

			

				
					
需要的拿去—Android手表和手机通讯研究

				
			

			

				

					Wood的专栏
				

				

					04-30
					
					3727
					
				

			

		

		

			
				
手机和手表的通讯是通过数据层来完成的，数据层这个概念这里解释一下：手机和手表通过蓝牙连接起来，相同包的应用(比如手机有一个包名为com.soufun.app的应用，手表也有一个相同包名的应用)由系统自动分配一个数据层的概念，所有涉及手机手表之间的数据通讯的工作都通过数据层来实现。只要有相同包名的应用同时安装在了手机和手表上，则系统就自动生成一个数据层来管理手机和手表的数据变化。

手机和手表之

			
		

	





	

		

			

				
					
android 跨进程通信aidl

				
			

			

				

					12-25
				

			

		

		

			
				
项目包括两部分，客户端和服务端，分别介绍了两个客户端的通信实现，及潜在的问题，由浅入深，其中包括基本数据类型和自定义数据类型的接口格式。

			
		

	





	

		

			

				
					
Android安全开发编码规范（上）

				
			

			

				

					武天旭的博客
				

				

					12-08
					
					857
					
				

			

		

		

			
				
一、平台使用不当
1.1、定义
平台使用不当包涵Android控件的配置不当或编码不当。包括Activity、Service、ContentProvider、Broadcast Receiver、Intent组件、WebView组件使用过程中配置是否规范与编码是否规范。
1.2、风险
平台使用不当会造成的风险包括组件被恶意调用、恶意发送广播、恶意启动应用服务、恶意调用组件、拦截组件返回的数据、远程代码执行等。
1.3、防范方法
1.3.1、预防组件最小化组件暴露
【规范要求】
针对不需要进行跨应用调用的组件

			
		

	





	

		

			

				
					
android service使用handle,使用Handler实现Activity和Service之间的交互

				
			

			

				

					weixin_39638105的博客
				

				

					05-27
					
					1600
					
				

			

		

		

			
				
在开发应用的时候，我们有时候需要Service来处理后台任务。同时需要两者之间的实时交互，比如说下载的时候我们需要实时地更新Notification的下载进度。我们可以通过BroadcastReceiver来实现Service和Activity的交互，但是今天我们来介绍另外一种实现方法。使用Handler实现Activity和Service之间的交互。实现的原理：1.在Service中的onCre...

			
		

	





	

		

			

				
					
Android  Service与Activity之间通信的几种方式

				
			

			

				

					www.v5qq.com的技术博客
				

				

					08-05
					
					2054
					
				

			

		

		

			
				
转载请注明地址http://blog.csdn.net/xiaanming/article/details/9750689

在Android中，Activity主要负责前台页面的展示，Service主要负责需要长期运行的任务，所以在我们实际开发中，就会常常遇到Activity与Service之间的通信，我们一般在Activity中启动后台Service，通过Intent来启动，Intent中...

			
		

	





	

		

			

				
					
Android学习之Activity与Service进行通信的三种方式

					
热门推荐

				
			

			

				

					run 的博客
				

				

					08-07
					
					3万+
					
				

			

		

		

			
				
Activity与Service进行通信的三种方式第一种 简单通信直接通过Intent进行传值，我们在启动一个Service的时候通过Intent的对象向Service进行传值，这种方式传递值比较不方便，性能不是很高。（1）在MainActivity中通过启动服务和终止服务的按钮分别调用startService(intent)和stopService(intent)来启动和停止服务MainActi...

			
		

	





	

		

			

				
					
Activity、Service几种通信方式

				
			

			

				

					chen1026241686的专栏
				

				

					09-11
					
					941
					
				

			

		

		

			
				
1.Binder方式，虽然能拿到服务类的实例，调用服务里面的公共方法，但是服务怎么去调用Activity的方法。

2.Service内部定义接口，然后由Activity接口，把实现的对象传递给Service，但是传递的话，还得需要Binder?或者静态函数？

好处是由于Binder和接口，所以基本上实现了双方的通信？

3.Activity.startService,每次往Intent里面传递不同的值，Service在onStartCommand里面取出来。弊端，Service不能给Activity传递

			
		

	





	

		

			

				
					
Service与Activity之间通信的2种方式

				
			

			

				

					Chin_Style的博客
				

				

					03-27
					
					3万+
					
				

			

		

		

			
				
一、前期基础知识储备（1）Service基础知识部分——参见笔者《Service精炼详解》，文章对于Service的简介、分类、实现、注意事项均有比较详细的说明；（2）为何要进行Secvice和Activity的通信？常用的服务一般是普通服务，即是不可交互的后台服务，该服务在活动中启动，但是启动之后，活动基本就和服务没有什么关系了。确实如此，我们在普通服务里是用startService()方法来启...

			
		

	





	

		

			

				
					
Android(java方法）上实现mp4的分割和拼接 （二）

				
			

			

				

					banking17173的专栏
				

				

					03-06
					
					9785
					
				

			

		

		

			
				
这节谈一下如何在android上实现mp4文件的高效率切割。
        业务需求举例：把一段2分钟的mp4文件切割出00：42 至 01:16这段时间的视频，要求足够短的执行时间和尽量少的误差。
        分析：mp4Parser只能在关键帧切割，比如，在00:40和00:45分别存在一个可切割关键帧，那么切割视频的头和尾，都应该选择短切割。然后获取到误差的视频短，如果这个误差大于

			
		

	





	

		

			

				
					
android4.2中AES加密算法的失效问题

				
			

			

				

					banking17173的专栏
				

				

					11-28
					
					5324
					
				

			

		

		

			
				
今天同事用刚升级的Android 4.2系统的手机测试发现保存在prefrence中的用户名无法获取到，最终锁定到的问题是框架中使用的AES算法对于新版本SDK失效。具体表现是
传入同样的秘钥和加密明文（下文中的seed和clearText)运行两次，最终生成的string类型密文不相同。直接贴代码
       	private final static String HEX = "0123

			
		

	





	

		

			

				
					
Android Service与Activity通信实战：MyBinder示例

				
			

			

				

					
				

			

		

		

			
				
"Android中Service和Activity相互通信示例代码"  在Android应用开发中，Service是后台长时间运行的组件，而Activity则主要处理用户界面交互。两者间的通信是实现复杂功能的关键，例如在用户不与界面交互时维持音乐...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值