《Android开发进阶：从小工到专家》——第1章，第1.2节Service与AIDL-低调大师

《Android开发进阶：从小工到专家》——第1章，第1.2节Service与AIDL

2017-05-01 522

本节书摘来自异步社区《Android开发进阶：从小工到专家》一书中的第1章，第1.2节Service与AIDL，作者何红辉，更多章节内容可以访问云栖社区“异步社区”公众号查看

1.2　Service与AIDL
Service是Android中实现程序后台运行的解决方案，它非常适合用于去执行那些不需要和用户交互而且还要求长期运行的任务。但不要被“后台”二字所迷惑，Service默认并不会运行在子线程中，它也不运行在一个独立的进程中，它同样执行在UI线程中，因此，不要在Service中执行耗时的操作，除非你在Service中创建了子线程来完成耗时操作。

Service的运行不依赖于任何用户界面，即使程序被切换到后台或者用户打开了另外一个应用程序，Service仍然能够保持正常运行，这也正是Service的使用场景。当某个应用程序进程被杀掉时，所有依赖于该进程的Service也会停止运行。

1.2.1　普通Service
Service的生命周期相对Activity来说简单得多，只有3个，分别为onCreate、onStartCommand和onDestory。一旦在项目的任何位置调用了Context 的startService()函数，相应的服务就会启动起来，首次创建时会调用onCreate函数，然后回调onStartCommand()函数。服务启动了之后会一直保持运行状态，直到stopService()或stopSelf()函数被调用。虽然每调用一次startService()函数，onStartCommand()就会执行一次，但实际上每个服务都只会存在一个实例。所以不管你调用了多少次startService()函数，只需调用一个stopService()或stopSelf()函数，服务就会被停止。

通常的Service大致如下：

public class MyService extends Service {

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

    private void doMyJob(Intent intent){
        // 从Intent中获取数据
        // 执行相关操作
        new Thread(){
            @Override
            public void run() {
                // 耗时操作
            }
        }.start();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

与Activity一样，Service也需要在AndroidManifest.xml中进行注册，示例如下：

<service android:name=".service.MyService" />

上述示例表示注册一个在应用包service目录下的MyService服务，注册之后，当用户调用startService(new Intent(mContext，MyService.class)) 时会调用onStartCommand函数，我们在该函数中调用doMyJob，而在doMyJob中我们创建了一个线程来执行耗时操作，以避免阻塞UI线程。当我们的Service完成使命时，需要调用stopService来停止该服务。

1.2.2　IntentService
完成一个简单的后台任务需要这么麻烦，Android显然早就“洞察”了这一点。因此，提供了一个IntentService来完成这样的操作，IntentService将用户的请求执行在一个子线程中，用户只需要覆写onHandleIntent函数，并且在该函数中完成自己的耗时操作即可。需要注意的是，在任务执行完毕之后IntentService会调用stopSelf自我销毁，因此，它适用于完成一些短期的耗时任务。示例如下：

  public class MyIntentService extends IntentService {

    MyIntentService(){
        super(MyIntentService.class.getName());
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        // 这里执行耗时操作
    }
}

1.2.3　运行在前台的Service
Service默认是运行在后台的，因此，它的优先级相对比较低，当系统出现内存不足的情况时，它就有可能会被回收掉。如果希望Service可以一直保持运行状态，而不会由于系统内存不足被回收，可以将Service运行在前台。前台服务不仅不会被系统无情地回收，它还会在通知栏显示一条消息，下拉状态栏后可以看到更加详细的信息。例如，墨迹天气在前台运行了一个Service，并且在Service中定时更新通知栏上的天气信息，如图1-11所示。

2429ea1c9e6efbf07cc365e7e33257bb48c35d35

下面我们就来实现一个类似于如图1-11所示的效果，首先我们定义一个服务，代码如下：

public class WeatherService extends Service {

    private static final int NOTIFY_ID = 123;

    @Override
    public void onCreate() {
        super.onCreate();
        showNotification();
    }

    /**
     * 在通知栏显示天气信息
     */
    private void showNotification() {
        NotificationCompat.Builder mBuilder =
                new NotificationCompat.Builder(this)
                        .setSmallIcon(R.drawable.weather)
                        .setContentTitle(getText(R.string.the_day))
                        .setContentText(getText(R.string.weather));
        // 创建通知被点击时触发的Intent
        Intent resultIntent = new Intent(this, MainActivity.class);

        // 创建任务栈Builder
        TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
        stackBuilder.addParentStack(MainActivity.class);
        stackBuilder.addNextIntent(resultIntent);
        PendingIntent resultPendingIntent =
                stackBuilder.getPendingIntent(
                        0, PendingIntent.FLAG_UPDATE_CURRENT);
        mBuilder.setContentIntent(resultPendingIntent);
        NotificationManager mNotifyMgr =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        // 构建通知
        final Notification notification = mBuilder.build() ;
        // 显示通知
        mNotifyMgr.notify(NOTIFY_ID, notification);
        // 启动为前台服务
        startForeground(NOTIFY_ID, notification);
    }
}

我们在onCreate函数中调用了showNotification函数显示通知，并且在最后调用startForeground将服务设置为前台服务。在AndroidManifest.xml注册之后我们就可以启动该Service了。效果如图1-12所示。

b7988293dbf1e31e9bbfcf663b2f99d9f83c059f

1.2.4　AIDL（Android接口描述语言）
AIDL（Android接口描述语言）是一种接口描述语言，通常用于进程间通信。编译器根据AIDL文件生成一个系列对应的Java类，通过预先定义的接口以及Binder机制达到进程间通信的目的。说白了，AIDL就是定义一个接口，客户端(调用端)通过bindService来与远程服务端建立一个连接，在该连接建立时会返回一个IBinder对象，该对象是服务端Binder的BinderProxy，在建立连接时，客户端通过asInterface函数将该BinderProxy对象包装成本地的Proxy，并将远程服务端的BinderProxy对象赋值给Proxy类的mRemote字段，就是通过mRemote执行远程函数调用。

在客户端新建一个AIDL文件，如图1-13所示。

620c6367c5c06359b8e92e28a5c873794bbc991d

在SsoAuth.aidl文件中会默认有一个basicTypes函数，我们在程序后面添加一个ssoAuth的函数用于SSO授权。代码如下：

interface SsoAuth {
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);

    /**
     * 实现SSO授权
     */
     void ssoAuth(String userName, String pwd);
}

因为客户端是调用端，因此，只需要定义AIDL文件，此时Rebuild一下工程就会生成一个SsoAuth.java类，该类根据SsoAuth.aidl文件生成，包含了我们在AIDL文件中定义的函数。因为AIDL通常用于进程间通信，因此，我们新建一个被调用端的工程，我们命名为aidl_server，然后将客户端的AIDL文件夹复制到aidl_server的app/src/main目录下，结构如图1-14所示。

afbc855a6d11d64b319ce97ca5934e6b7f461774

此时相当于在客户端和被调用端都有同一份SsoAuth.aidl文件，它们的包名、类名完全一致，生成的SsoAuth.java类也完全一致，这样在远程调用时它们就能够拥有一致的类型。Rebuild被调用端工程之后就会生成SsoAuth.java文件，该文件中有一个Stub类实现了SsoAuth接口。我们首先需要定义一个Service子类，然后再定义一个继承自Stub的子类，并且在Service的onBind函数中返回这个Stub子类的对象。示例代码如下：

public class SinaSsoAuthService extends Service {

    SinaSsoImpl mBinder = new SinaSsoImpl();

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("","### sso auth created") ;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    // 继承自Stub类,在这里实现ssoAuth函数
    class SinaSsoImpl extends SsoAuth.Stub {

        @Override
        public void ssoAuth(String userName, String pwd) throws RemoteException {
            Log.e("", "这里是新浪客户端, 执行SSO登录啦,用户名 : " 
                                      + userName + ", 密码 : " + pwd) ;
        }

        @Override
        public void basicTypes(int anInt, long aLong,
            boolean aBoolean, float aFloat,
            double aDouble, String aString) throws RemoteException {
        }
    }
}

从上述代码中我们看到，实际上完成功能的是继承自Stub的SinaSsoImpl类，Service只提供了一个让SinaSsoImpl依附的外壳。完成SinaSsoAuthService之后我们需要将它注册在被调用端应用的Manifest中，注册代码如下：

<service
    android:name=".service.SinaSsoAuthService"
    android:exported="true"
    android:process=":remote"
    android:label="@string/app_name">
  <intent-filter>
          <action android:name="book.aidl_server.service.SinaSsoAuthService"/>
  </intent-filter>
</service>

然后先运行被调用端（也就是Server端）应用，并且在客户端中完成调用Server的代码。客户端Activity的代码如下：

public class MainActivity extends AppCompatActivity {

    SsoAuth mSsoAuth ;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 执行操作
        findViewById(R.id.sso_btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if ( mSsoAuth == null ) {
                    // 绑定远程服务,并且进行登录
                    bindSsoAuthService();
                } else {
                    doSsoAuth();
                }
            }
        });
    }

    private void bindSsoAuthService() {
        Intent intent = new Intent("book.aidl_server.service.SinaSsoAuthService") ;
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE) ;
    }

    ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            // 建立连接之后将Binder转换为mSsoAuth
            mSsoAuth = SsoAuth.Stub.asInterface(iBinder) ;
            doSsoAuth();
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mSsoAuth = null;
        }
    } ;

    private void doSsoAuth() {
        try {
            // 执行登录,实际上调用的是Server端的ssoAuth函数
            mSsoAuth.ssoAuth("Mr.Simple", "pwd123");
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mConnection);
    }
}

在上述Activity程序中，运行程序后点击登录按钮时会向Server端发起连接Service请求，在建立连接之后会将Binder对象转换为SsoAuth对象，然后调用SsoAuth对象的ssoAuth函数。此时的ssoAuth函数实际上调用的就是Server端中SinaSsoImpl类的实现。运行程序后点击登录按钮，如图1-15所示。

c777f0f157140b5798e2fd1cd6b92c398751b773

这一切的核心都是通过AIDL文件生成的Stub类以及其背后的Binder机制。首先我们看看生成的SsoAuth.java，Stub类就是该文件中的内部类。代码如下：

// 根据SsoAuth.aidl生成的接口
public interface SsoAuth extends android.os.IInterface{
    /** Stub类继承自Binder，并且实现了SsoAuth接口 */
    public static abstract class Stub extends android.os.Binder 
        implements book.jtm_chap01.SsoAuth {
        private static final java.lang.String DESCRIPTOR = "book.jtm_chap01.SsoAuth";
        public Stub(){
            this.attachInterface(this, DESCRIPTOR);
        }
        /**
         * 将Binder转换为 book.jtm_chap01.SsoAuth接口或者包装为一个Proxy
         */
        public static book.jtm_chap01.SsoAuth asInterface(android.os.IBinder obj){
            if ((obj==null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin!=null)&&(iin instanceof book.jtm_chap01.SsoAuth))) {
                return ((book.jtm_chap01.SsoAuth)iin);
            }
            return new book.jtm_chap01.SsoAuth.Stub.Proxy(obj);
        }
        @Override public android.os.IBinder asBinder(){
            return this;
        }
        @Override public boolean onTransact(int code, 
             android.os.Parcel data, android.os.Parcel reply, 
             int flags) throws android.os.RemoteException{
            switch (code){
                 case INTERFACE_TRANSACTION:{
                    reply.writeString(DESCRIPTOR);
                    return true;
                 }
                 case TRANSACTION_basicTypes:{
                    data.enforceInterface(DESCRIPTOR);
                     // 代码省略
                    return true;
                 }
                case TRANSACTION_ssoAuth:    // 执行ssoAuth函数时提交给Binder的数据
                {
                    data.enforceInterface(DESCRIPTOR);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    java.lang.String _arg1;
                    _arg1 = data.readString();
                    this.ssoAuth(_arg0, _arg1);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        // 本地代理，通过Binder与服务端的对象进行交互
        private static class Proxy implements book.jtm_chap01.SsoAuth{
            private android.os.IBinder mRemote;
            Proxy(android.os.IBinder remote){
                mRemote = remote;
            }
            @Override public android.os.IBinder asBinder(){
                return mRemote;
            }
             // 代码省略
            /**
             * 实现SSO授权
             */
             @Override public void ssoAuth(java.lang.String userName, 
                      java.lang.String pwd) throws android.os.RemoteException{
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeString(userName);
                    _data.writeString(pwd);
                    mRemote.transact(Stub.TRANSACTION_ssoAuth, _data, _reply, 0);
                    _reply.readException();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }
        static final int TRANSACTION_basicTypes 
                     = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_ssoAuth 
                     = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }

    public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double   
    aDouble, java.lang.String aString) throws android.os.RemoteException;
    // 实现SSO授权
    public void ssoAuth(java.lang.String userName, java.lang.String pwd) 
               throws android.os.RemoteException;
}

在SsoAuth.java中自动生成了SsoAuth接口，该接口中有一个ssoAuth函数。但最，重要的是生成了一个Stub类，该类继承自Binder类，并且实现了SsoAuth接口。Stub里面最重要的就是asInterface()这个函数，在这个函数中会判断obj参数的类型，如果该obj是本地的接口类型，则认为不是进程间调用，此时将该obj转换成SsoAuth类型；否则会通过自动生成的另一个内部类Proxy来包装obj，将其赋值给Proxy中的mRemote字段。Proxy类也实现了SsoAuth接口，不同的是它是通过Binder机制来与远程进程进行交互，例如，在ssoAuth ()函数中，Proxy将通过Binder机制向服务端传递请求和数据，它请求的类型为TRANSACTION_ssoAuth，参数分别是String类型的userName和pwd。

对于服务端代码来说，它也有同一份SsoAuth.aidli以及SsoAuth.java，但不同的是服务端是指令的接收端，客户端的调用会通过Binder机制传递到服务端，最终调用Stub类中的onTransact函数。可以看到在case TRANSACTION_ssoAuth处执行了this.ssoAuth()函数，意思是当接收到客户端的TRANSACTION_ssoAuth请求时，执行this.ssoAuth()函数，通过客户端的分析我们知道，当我们调用ssoAuth()时实际上就是通过mRemote向服务端提交了一个TRANSACTION_ssoAuth请求，因此，这两端通过Binder机制就对接上了，我们可以简单地理解为C/S模式。

而在客户端调用bindService之后，如果绑定成功则会调用onServiceConnected(ComponentName name，IBinder service)，这里的Service对象是BinderProxy类型，经过asInterface转换后被包装成了Proxy类型，但是调用的时候，执行的是服务端SinaSsoImpl中的ssoAuth()函数。因此， SinaSsoImpl实例mBinder被服务端包装成BinderProxy类型，再经过客户端的Proxy进行包装，通过Binder机制进行数据传输，实现进程间调用。

它们的调用时序图如图1-17所示。

cd44e3eb5b00aa5ef3cf1390654ec86c830d1271

打个比方说，有两个公司打算进行合作需要进行业务磋商，并且这次合作已经签署了合同，只剩下一些细节没有最终确定。但是由于大BOSS比较忙，因此各自都派了一个代表进行沟通。由于两家公司相距较远，双方代表都通过电话进行沟通。BOSS-A跟代表-A交代说，这次合作对方支付的酬劳不能低于十块钱，于是代表-A通过电话与代表B进行沟通，代表-B得到消息之后跑到BOSS-B的办公室请示，BOSS-B确认之后又由代表-B回复代表-A，代表-A最终反馈给BOSS-A。这个例子中的两个BOSS分别对应客户端和服务端，合同就对应了SsoAuth接口，而两个代表则对应了两端的Proxy，代表的通信方式则是电话，而代码的通信方式是Binder。

总体来说，使用AIDL并不是一件困难的事，但是理解AIDL的机制确实有一定的难度。也正是如此，Android通过AIDL这个机制将一些复杂的概念与逻辑通过自动生成类型的方式屏蔽掉，使得开发人员能够更简单地进行进程间通信。

微信关注我们

原文链接：https://yq.aliyun.com/articles/93111

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

《Android 3D游戏开发技术宝典——OpenGL ES 2.0》——2.2节简单数据的存储——Preferences

本节书摘来自异步社区《Android 3D游戏开发技术宝典——OpenGL ES 2.0》一书中的第2章，第2.2节简单数据的存储——Preferences，作者吴亚峰，更多章节内容可以访问云栖社区“异步社区”公众号查看 2.2 简单数据的存储——PreferencesAndroid 3D游戏开发技术宝典——OpenGL ES 2.0进行游戏开发时，有时需要持久地存储一些十分简单的数据，例如，游戏中音效的开关状态、振动效果的开关状态等。Android设计者也充分注意到了这种存储简单数据的需求，提供了一个Preferences类专门用于完成此类任务。 2.2.1 Preferences简介Preferences使用非常方便，但功能也不是很强大，一般适合用来保存一些用户设置的参数，是一种轻量级的数据存储机制。Preferences仅可以用来存储几种简单类型的数据，如：boolean、int、float、long或者String。这些数据以键值对的形式存储在应用程序私有的Preferences目录（/data/data/应用程序包名/shared_prefs/）下的特定xml文件中，如图2...

2017-05-02

541

本节书摘来自异步社区《精通Android 实例开发》一书中的第1章，第1.15节向Eclipse中导入Android程，作者陈强，更多章节内容可以访问云栖社区“异步社区”公众号查看 1.15 向Eclipse中导入Android程 1.15.1 实例说明使用过Eclipse的读者应该知道，我们可以向Eclipse中导入已经存在的工程文件。作为一款开发工具，这个功能是必须具备的。工程项目不可能全部是一次性完成的，总是写一部分程序然后保存，经过多次修改和多次保存后才完成一个项目。本实例将演示向Eclipse中导入Android程序的方法。 1.15.2 具体实现（1）打开Eclipse，依次单击【File】︱【Import】命令，如图1-81所示。（2）在弹出界面中选择“Existing Projects into Workspace”选项，然后单击【Next】按钮，如图1-82所示。（3）在弹出的“Import Projects”界面中选择“Select root directory”单选框，然后单击后面的【Browse】按钮，如图1-83所示。（4）在弹出的“浏览文件夹”对话框...

2017-05-02

635

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。