看过的写的比较好的service之AIDL

最新推荐文章于 2024-04-09 03:27:44 发布
最新推荐文章于 2024-04-09 03:27:44 发布
阅读量532 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oMartin1/article/details/46787363
版权

本文将以一个例子来和你分享使用AIDL的基础技能，这个例子里有：

1、一个类mAIDLActivity，继承Activity。里面有三个按钮，text分别为StartService，StopService，CallbackTest。

2、一个类mAIDLService，继承Service。为了充分展示ADIL的功能，它做以下工作：当用户点击CallbackTest按钮时，从mAIDLActivity调用mAIDLService中的Stub 对象的一个方法invokCallBack()，而这个方法又会调用mAIDLActivity中Stub 对象的一个方法performAction()，这个方法在屏幕上显示一个toast。没什么意义，只是展示一下AIDL如何使用。

3、两个AIDL文件：forService.aidl和forActivity.aidl。对应名字，在Service和Activity中分别有对象需要用到它们定义的接口。

    

开发环境为Eclipse。

拣重要的先说，来看看aidl文件的内容：

文件：forActivity.aidl

 

  1. package com.styleflying.AIDL;  
  2. interface forActivity {  
  3.     void performAction();  
  4.     }  
 

文件：forService.aidl

 

  1. package com.styleflying.AIDL;  
  2. import com.styleflying.AIDL.forActivity;  
  3. interface forService {  
  4.     void registerTestCall(forActivity cb);  
  5.     void invokCallBack();  
  6. }  
 

这两个文件和Java文件放置的地方一样，看包名。

在Eclipse中它们将被自动编译为forActivity.java和forService.java，它们存放在gen目录下。为了方便手头无法演练的读者，代码贴上，不用细看。

文件forActivity.java：

 

  1.   
  2. package com.styleflying.AIDL;  
  3. import java.lang.String;  
  4. import android.os.RemoteException;  
  5. import android.os.IBinder;  
  6. import android.os.IInterface;  
  7. import android.os.Binder;  
  8. import android.os.Parcel;  
  9. public interface forActivity extends android.os.IInterface  
  10. {  
  11.   
  12. public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.forActivity  
  13. {  
  14. private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.forActivity";  
  15.   
  16. public Stub()  
  17. {  
  18. this.attachInterface(this, DESCRIPTOR);  
  19. }  
  20.   
  21. public static com.styleflying.AIDL.forActivity asInterface(android.os.IBinder obj)  
  22. {  
  23. if ((obj==null)) {  
  24. return null;  
  25. }  
  26. android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  27. if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.forActivity))) {  
  28. return ((com.styleflying.AIDL.forActivity)iin);  
  29. }  
  30. return new com.styleflying.AIDL.forActivity.Stub.Proxy(obj);  
  31. }  
  32. public android.os.IBinder asBinder()  
  33. {  
  34. return this;  
  35. }  
  36. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  37. {  
  38. switch (code)  
  39. {  
  40. case INTERFACE_TRANSACTION:  
  41. {  
  42. reply.writeString(DESCRIPTOR);  
  43. return true;  
  44. }  
  45. case TRANSACTION_performAction:  
  46. {  
  47. data.enforceInterface(DESCRIPTOR);  
  48. this.performAction();  
  49. reply.writeNoException();  
  50. return true;  
  51. }  
  52. }  
  53. return super.onTransact(code, data, reply, flags);  
  54. }  
  55. private static class Proxy implements com.styleflying.AIDL.forActivity  
  56. {  
  57. private android.os.IBinder mRemote;  
  58. Proxy(android.os.IBinder remote)  
  59. {  
  60. mRemote = remote;  
  61. }  
  62. public android.os.IBinder asBinder()  
  63. {  
  64. return mRemote;  
  65. }  
  66. public java.lang.String getInterfaceDescriptor()  
  67. {  
  68. return DESCRIPTOR;  
  69. }  
  70. public void performAction() throws android.os.RemoteException  
  71. {  
  72. android.os.Parcel _data = android.os.Parcel.obtain();  
  73. android.os.Parcel _reply = android.os.Parcel.obtain();  
  74. try {  
  75. _data.writeInterfaceToken(DESCRIPTOR);  
  76. mRemote.transact(Stub.TRANSACTION_performAction, _data, _reply, 0);  
  77. _reply.readException();  
  78. }  
  79. finally {  
  80. _reply.recycle();  
  81. _data.recycle();  
  82. }  
  83. }  
  84. }  
  85. static final int TRANSACTION_performAction = (IBinder.FIRST_CALL_TRANSACTION + 0);  
  86. }  
  87. public void performAction() throws android.os.RemoteException;  
  88. }  

文件forService.java：

 

  1.   
  2. package com.styleflying.AIDL;  
  3. import java.lang.String;  
  4. import android.os.RemoteException;  
  5. import android.os.IBinder;  
  6. import android.os.IInterface;  
  7. import android.os.Binder;  
  8. import android.os.Parcel;  
  9. public interface forService extends android.os.IInterface  
  10. {  
  11.   
  12. public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.forService  
  13. {  
  14. private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.forService";  
  15.   
  16. public Stub()  
  17. {  
  18. this.attachInterface(this, DESCRIPTOR);  
  19. }  
  20.   
  21. public static com.styleflying.AIDL.forService asInterface(android.os.IBinder obj)  
  22. {  
  23. if ((obj==null)) {  
  24. return null;  
  25. }  
  26. android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  27. if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.forService))) {  
  28. return ((com.styleflying.AIDL.forService)iin);  
  29. }  
  30. return new com.styleflying.AIDL.forService.Stub.Proxy(obj);  
  31. }  
  32. public android.os.IBinder asBinder()  
  33. {  
  34. return this;  
  35. }  
  36. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  37. {  
  38. switch (code)  
  39. {  
  40. case INTERFACE_TRANSACTION:  
  41. {  
  42. reply.writeString(DESCRIPTOR);  
  43. return true;  
  44. }  
  45. case TRANSACTION_registerTestCall:  
  46. {  
  47. data.enforceInterface(DESCRIPTOR);  
  48. com.styleflying.AIDL.forActivity _arg0;  
  49. _arg0 = com.styleflying.AIDL.forActivity.Stub.asInterface(data.readStrongBinder());  
  50. this.registerTestCall(_arg0);  
  51. reply.writeNoException();  
  52. return true;  
  53. }  
  54. case TRANSACTION_invokCallBack:  
  55. {  
  56. data.enforceInterface(DESCRIPTOR);  
  57. this.invokCallBack();  
  58. reply.writeNoException();  
  59. return true;  
  60. }  
  61. }  
  62. return super.onTransact(code, data, reply, flags);  
  63. }  
  64. private static class Proxy implements com.styleflying.AIDL.forService  
  65. {  
  66. private android.os.IBinder mRemote;  
  67. Proxy(android.os.IBinder remote)  
  68. {  
  69. mRemote = remote;  
  70. }  
  71. public android.os.IBinder asBinder()  
  72. {  
  73. return mRemote;  
  74. }  
  75. public java.lang.String getInterfaceDescriptor()  
  76. {  
  77. return DESCRIPTOR;  
  78. }  
  79. public void registerTestCall(com.styleflying.AIDL.forActivity cb) throws android.os.RemoteException  
  80. {  
  81. android.os.Parcel _data = android.os.Parcel.obtain();  
  82. android.os.Parcel _reply = android.os.Parcel.obtain();  
  83. try {  
  84. _data.writeInterfaceToken(DESCRIPTOR);  
  85. _data.writeStrongBinder((((cb!=null))?(cb.asBinder()):(null)));  
  86. mRemote.transact(Stub.TRANSACTION_registerTestCall, _data, _reply, 0);  
  87. _reply.readException();  
  88. }  
  89. finally {  
  90. _reply.recycle();  
  91. _data.recycle();  
  92. }  
  93. }  
  94. public void invokCallBack() throws android.os.RemoteException  
  95. {  
  96. android.os.Parcel _data = android.os.Parcel.obtain();  
  97. android.os.Parcel _reply = android.os.Parcel.obtain();  
  98. try {  
  99. _data.writeInterfaceToken(DESCRIPTOR);  
  100. mRemote.transact(Stub.TRANSACTION_invokCallBack, _data, _reply, 0);  
  101. _reply.readException();  
  102. }  
  103. finally {  
  104. _reply.recycle();  
  105. _data.recycle();  
  106. }  
  107. }  
  108. }  
  109. static final int TRANSACTION_registerTestCall = (IBinder.FIRST_CALL_TRANSACTION + 0);  
  110. static final int TRANSACTION_invokCallBack = (IBinder.FIRST_CALL_TRANSACTION + 1);  
  111. }  
  112. public void registerTestCall(com.styleflying.AIDL.forActivity cb) throws android.os.RemoteException;  
  113. public void invokCallBack() throws android.os.RemoteException;  
  114. }  

两段代码差不多，前面基本一样，从后面看，最后跟着我们在AIDL中自定义的方法，没有实现。两个文件各定义一个了接口，这两个接口分别会在Activity和Service中使用，在那里我们将实现自定义的方法。两个接口中都定义了一个抽象类Stub，实现所在的接口。Stub中又有一个类Proxy。Stub中有一个static的asInterface()方法，里面有很多return语句，在mAIDLActivity中调用它时，它返回一个新创建的内部类Proxy对象。

这个Stub对我们来说很有用，它继承了Binder。Binder有什么用呢？一个类，继承了Binder，那么它的对象就可以被远程的进程使用了(前提是远程进程获取了这个类的对象【对象的引用】，至于如如何获得看下文)，在本例中就是说，如果一个Service中有一个继承了Stub的类的对象，那么这个对象中的方法就可以在Activity中使用，对Activity也是这样。至于Binder的细节，网上有很多贴介绍，看不明白也不影响我们完成这个例子。

再看mAIDLActivity.java:

 

  1. package com.styleflying.AIDL;  
  2. import android.app.Activity;  
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.IBinder;  
  9. import android.os.RemoteException;  
  10. import android.util.Log;  
  11. import android.view.View;  
  12. import android.view.View.OnClickListener;  
  13. import android.widget.Button;  
  14. import android.widget.Toast;  
  15. public class mAIDLActivity extends Activity {  
  16.     private static final String TAG = "AIDLActivity";  
  17.     private Button btnOk;  
  18.     private Button btnCancel;  
  19.     private Button btnCallBack;  
  20.       
  21.     private void Log(String str) {  
  22.         Log.d(TAG, "------ " + str + "------");  
  23.         }  
  24.       
  25.     private forActivity mCallback = new forActivity.Stub() {  
  26.         public void performAction() throws RemoteException  
  27.         {  
  28.             Toast.makeText(mAIDLActivity.this, "this toast is called from service", 1).show();  
  29.         }  
  30.         };  
  31.           
  32.     forService mService;  
  33.     private ServiceConnection mConnection = new ServiceConnection() {  
  34.         public void onServiceConnected(ComponentName className,  
  35.                 IBinder service) {  
  36.             mService = forService.Stub.asInterface(service);  
  37.             try {  
  38.                 mService.registerTestCall(mCallback);}  
  39.             catch (RemoteException e) {  
  40.                   
  41.             }  
  42.             }  
  43.         public void onServiceDisconnected(ComponentName className) {  
  44.             Log("disconnect service");  
  45.             mService = null;  
  46.             }  
  47.         };  
  48.     @Override  
  49.     public void onCreate(Bundle icicle) {  
  50.         super.onCreate(icicle);  
  51.         setContentView(R.layout.main);  
  52.         btnOk = (Button)findViewById(R.id.btn_ok);  
  53.         btnCancel = (Button)findViewById(R.id.btn_cancel);  
  54.         btnCallBack = (Button)findViewById(R.id.btn_callback);  
  55.         btnOk.setOnClickListener(new OnClickListener() {  
  56.             public void onClick(View v) {  
  57.                 Bundle args = new Bundle();  
  58.                 Intent intent = new Intent(mAIDLActivity.this, mAIDLService.class);  
  59.                 intent.putExtras(args);  
  60.                 bindService(intent, mConnection, Context.BIND_AUTO_CREATE);  
  61.                 startService(intent);  
  62.                 }  
  63.             });  
  64.         btnCancel.setOnClickListener(new OnClickListener() {  
  65.             public void onClick(View v) {  
  66.                 unbindService(mConnection);  
  67.                 //stopService(intent);   
  68.                 }  
  69.             });  
  70.         btnCallBack.setOnClickListener(new OnClickListener() {  
  71.               
  72.             @Override  
  73.             public void onClick(View v)  
  74.             {  
  75.                 try  
  76.                 {  
  77.                     mService.invokCallBack();  
  78.                 } catch (RemoteException e)  
  79.                 {  
  80.                     // TODO Auto-generated catch block   
  81.                     e.printStackTrace();  
  82.                 }  
  83.             }  
  84.         });  
  85.         }  
  86. }  

 

很短，相信大家很容易看明白。注意mConnection，它的onServiceConnected()中有一句mService = forService.Stub.asInterface(service);给mService赋值了，这个mService是一个forService，而service是onServiceConnected()传进来的参数，onServiceConnected()会在连接Service的时候被系统调用，这个service参数的值来自哪里呢？看mAIDLService.java:

 

  1. package com.styleflying.AIDL;  
  2. import android.app.Service;  
  3. import android.content.Intent;  
  4. import android.os.IBinder;  
  5. import android.os.RemoteCallbackList;  
  6. import android.os.RemoteException;  
  7. import android.util.Log;  
  8. public class mAIDLService extends Service {  
  9.     private static final String TAG = "AIDLService";    
  10.     private forActivity callback;  
  11.     private void Log(String str) {  
  12.         Log.d(TAG, "------ " + str + "------");  
  13.     }  
  14.     @Override  
  15.     public void onCreate() {  
  16.         Log("service create");  
  17.     }  
  18.     @Override  
  19.     public void onStart(Intent intent, int startId) {  
  20.         Log("service start id=" + startId);  
  21.     }  
  22.       
  23.     @Override  
  24.     public IBinder onBind(Intent t) {  
  25.         Log("service on bind");  
  26.         return mBinder;  
  27.     }  
  28.     @Override  
  29.     public void onDestroy() {  
  30.         Log("service on destroy");  
  31.         super.onDestroy();  
  32.     }  
  33.     @Override  
  34.     public boolean onUnbind(Intent intent) {  
  35.         Log("service on unbind");  
  36.         return super.onUnbind(intent);  
  37.     }  
  38.     public void onRebind(Intent intent) {  
  39.         Log("service on rebind");  
  40.         super.onRebind(intent);  
  41.     }  
  42.     private final forService.Stub mBinder = new forService.Stub() {  
  43.         @Override  
  44.         public void invokCallBack() throws RemoteException  
  45.         {  
  46.             callback.performAction();  
  47.               
  48.         }  
  49.         @Override  
  50.         public void registerTestCall(forActivity cb) throws RemoteException  
  51.         {  
  52.             callback = cb;  
  53.               
  54.         }  
  55.           
  56.     };  
  57. }  

注意onBind()，它的返回类型为IBinder，返回了一个mBinder，看看mBinder的定义：

    private final forService.Stub mBinder = new forService.Stub() {

        @Override
        public void invokCallBack() throws RemoteException
        {
            callback.performAction();
         }

        @Override
        public void registerTestCall(forActivity cb) throws RemoteException
        {
            callback = cb;

        }

       };

它是实现了我们在AIDL中定义的方法，这个mBinder最终返回给了mAIDLActivity中的mService，于是在mAIDLActivity中可以使用mBinder中的方法了。在mAIDLActivity中也有一个类似mBinder的对象，看看定义：   

        private forActivity mCallback = new forActivity.Stub()

    {
        public void performAction() throws RemoteException
        {
            Toast.makeText(mAIDLActivity.this, "this toast is called from service", 1).show();
        }
      };

我们要在界面上显示一个toast，就是在这里实现的。这个对象，在mConnection的onServiceConnected()被调用时，通过调用mService（也就是远程的mAIDLService中的mBinder）的registerTestCall()，传递给了mAIDLService，于是在mAIDLService中可以调用performAction()了。

做一个大致总结，我们使用AIDL是要做什么呢：

让Acticity（或者说一个进程/一个类？）和Service（或者说远端进程/远端类/对象？）获取对方的一个Stub对象，这个对象在定义时实现了我们在AIDL中定义的方法，于是这些远程对象中的方法可以在本地使用了。如果这种使用（通信）是单向的，比如只是Activity需要通知Service做什么，那么只要Service中有一个Stub对象，并且传给Acticity就够了。

至于如何获得远程的Stub，参看上面的代码，看mConnection、registerTestCall、onRebind，它们展示了一种方法。

另外，有时候我们可能在一个类中有多个Stub对象，它们都要给远程交互的类的实例，这个时候可以考虑使用RemoteCallbackList<>（docs/reference/android/os/RemoteCallbackList.html）。

大理皇室
关注
专栏目录
24 服务AIDL
weixin_30323961的博客
09-23 65
AIDL远程访问服务的方法 创建一个接口类写上方法 然后修改后缀java为aidl 在服务中创建一个类继承Stub类 在远程访问服务的进程把AIDL文件复制(包名不能改变) XXXX.Stub.asInterface(service);即可 服务端结构 MainActivity.java 无实际代码 MyService....
Android 之工具aidl
架构设计
05-10 202
AIDL服务支持的数据类型如下： Java的简单类型（int、char、boolean等）。不需要导入（import）。 String和CharSequence。不需要导入（import）。 List和Map。但要注意，List和Map对象的元素类型必须是AIDL服务支持的数据类型。不需要导入（import）。 AIDL自动生成的接口。需要导入（import）。 实现android.os...
引入aidl文件并调用
a1003434346的博客
03-22 4650
如何引入: 第一步: 找到需要导入工程的aidl文件.通过文本打开,找到文件中的具体包名 package woyou.aidlservice.jiuiv5; 第二步: 在studio的工程目录下app/src/main/下创建一个aidl文件夹(aidl文件夹是跟java文件夹是同级的,不要创建到java文件夹里面) 第三步: 依次创建跟之前找到的包名一样的文件夹,我这里是: ...
Service框架---关于aidl的使用介绍
fan380485838的专栏
08-10 501
Service框架---关于aidl的使用介绍 1.2　应用框架解析 除了基本的组件外，为了维护整个UI系统的良好运行，在应用层，Android还设计了诸多的框架来进行相关方面的管理。本节主要介绍Service框架、Activity管理机制、Broadcast机制、对话框框架、标题栏框架、状态栏框架、通知机制和ActionBar框架等。 1.2.1　Service框架
Android四大组件Service之AIDL详解
lijianbiao0的博客
12-19 383
前言 如果没有看过上篇的同学建议看看上篇的《Android四大组件之绑定Service详解》 简介 AIDL（Android 接口定义语言）与您可能使用过的其他 IDL 类似。 您可以利用它定义客户端与服务使用进程间通信 (IPC) 进行相互通信时都认可的编程接口。 在 Android 上，一个进程通常无法访问另一个进程的内存。 尽管如此，进程需要将其对象分解成操作系统能够识别的原语，并将对象编组...
android--service之aidl传递复杂对象,Android--Service之AIDL传递复杂对象
weixin_39530557的博客
05-27 199
前言Android的AIDL不仅可以在绑定服务中传递一些Android规定的数据类型的数据，还可以传递一些复杂类型的数据。但是与传递系统允许的数据类型相比，复杂类型数据的传递要做更多的工作，本篇博客就讲解一下如何使用AIDL接口通过绑定服务在进程间传递数据。关于AIDL传递规定类型数据的内容，不了解的朋友可以看看之前的博客：AIDL传递系统允许类型数据。本篇博客的主要内容：AIDL传递复杂类型对象...
Service与AIDL
timshinlee的博客
08-16 560
Service介绍Service是一个没有界面的系统组件，可以在后台进行一些长期的操作。这里的后台并不是指子线程，而是指在离开应用后仍然可以继续运行。Service一般由其他系统组件启动，可以用来实现IPC（Inter-Process Communication）。Service可以分为三种： scheduled Service：即用来定时进行一些操作，可以通过JobScheduler（API 21
Service(下）之aidl绑定
zzzypp的专栏
03-27 605
Service绑定，aidl绑定
Android Service学习之AIDL实例，正式加入字节跳动
最新发布
2301_82242988的博客
04-09 623
客户端实现回调接口@Override客户端如何与服务器绑定并建立连接@Overridetry {详细信息请见附件中的源码工程,希望对大家有用.
Android Service aidl分析
ITRenj的博客
11-07 401
《Android Service基础》 《Android Service回调和配置》 《Android Service aidl使用及进阶》 《Android Service更多知识》 《Android 中的 IntentService 类详解》 Android Service 代码地址 在介绍正文之前,我们先看看几个知识点进程、线程和Android中的进程间通讯(IPC)。 线程：线程时CPU调度的最小单元，同时线程也是一种有限的系统资源。 进程：进程一般表示一个执行单元，在..
Android系统中aidl的理解和service的添加
这都是什么
08-19 2542
概述 看看官方文档： AIDL（Android 接口定义语言）与您可能使用过的其他 IDL 类似。 您可以利用它定义客户端与服务使用进程间通信 (IPC) 进行相互通信时都认可的编程接口。 在 Android 上，一个进程通常无法访问另一个进程的内存。 尽管如此，进程需要将其对象分解成操作系统能够识别的原语，并将对象编组成跨越边界的对象。 编写执行这一编组操作的代码是一项繁琐的工作，因此 An
Android的进程间通信（三） 之 AIDL 通信 之AIDL使用方式与源码解析
共同交流与成长
10-09 465
AIDL使用方式与源码解析 继上一篇博客，这一篇我们将要介绍AIDL的使用方式和源码解析。先来看官网对于AIDL的定义： Android 接口定义语言 (AIDL) 与您可能使用过的其他接口语言 (IDL) 类似。您可以利用它定义客户端与服务均认可的编程接口，以便二者使用进程间通信 (IPC) 进行相互通信。 简单来说，AIDL是一种接口语言，服务端和客户端可通过AIDL定义接口后，编译器会自动生成相应的java代码，二者可以进行IPC通信。 如何使用？ 使用的步骤也很简单。 第一步：新建AIDL文件
Android Service学习之AIDL, Parcelable和远程服务
大数据处理，智能搜索推荐，自然语言处理，AI机器人对话，数据库读写分离
06-20 703
原作者：http://android.blog.51cto.com/268543/537684 AIDL的作用     由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI运行另一个服务进程，而且经常会在不同的进程间传递对象。在Android平台，一个进程通常不能访问另一个进程的内存空间，所以要想对话，需要将对象分解成操作系统可以理解的基本单元，并且有序的通过进程边界。
我的Android进阶之旅------>Android Service学习之AIDL, Parcelable和远程服务
字节卷动
04-09 3667
AIDL的作用     由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI运行另一个服务进程，而且经常会在不同的进程间传递对象。在Android平台，一个进程通常不能访问另一个进程的内存空间，所以要想对话，需要将对象分解成操作系统可以理解的基本单元，并且有序的通过进程边界。     通过代码来实现这个数据传输过程是冗长乏味的，Android提供了AIDL工具来处理这项工作。
Intent的几种有关Activity启动的方…
oMartin1的专栏
07-07 1141
activity与task的启动模式 通常情况下，一个应用有一个Task，这个Task就是为了完成某个工作的一系列Activity的集合。而这些Activity又被组织成了堆栈的形式。     当一个Activity启动时，就会把它压入该Task的堆栈，而当用户在该Activity中按返回键，或者代码中finish掉时，就会将它从该 Task的堆栈中弹出。如果我们没有特别的需求，我们的应用就会呈
点击滑动到指定位置
oMartin1的专栏
07-07 817
AnimationSet set = new AnimationSet(true);                 ScaleAnimation scaleAnim = new ScaleAnimation(1.0f, 0.0f, 1.0f,                         0.0f, 0.5f, 0.5f);                 set.addAnimation(s
PopupWindow setOutsideTouch…
oMartin1的专栏
07-07 747
pop.setBackgroundDrawable(new BitmapDrawable());响应返回键，响应触摸周边消失
Button显示不同字体
oMartin1的专栏
07-07 675
Button tx = (Button) findViewById(R.id.content);   String w = getResources().getString(R.string.hello);   Spannable wordtoSpan = new SpannableString(w);   wordtoSpan.setSpan(new AbsoluteSizeSpan(50),
Android AIDL实现跨APP Service通信详解
"这篇文档详细阐述了如何在两个Android应用之间使用AIDL（Android Interface Definition Language）进行Service通信。AIDL是一种实现跨进程调用的技术，允许不同进程（即不同应用）之间进行通信。通常，当一个应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值