Android_读书笔记_2

感觉Service有些纠结，不知道是不是因为书本的原因，书上的例子一个都没成功，看的也是晕头转向的。

一同提到了4个东西，前面嘛自然是那些巴拉巴拉的介绍，直接正题。

重点：

1.创建一个服务（Service）;

Android中Service是一个很重要的元素之一，一个 “服务”涉及到Service类的继承，以及在AndroidManifest.xml中添加相关权限许可代码

再者就是 Service类的基础方法，onCreate(), onBind(), onStart(), onStartCommand(), onDestory()......

定义服务的名称很重要，因为这可以让你的服务在其他应用程序中被使用（创建，启动，停止，销毁）.对于onStart() 和 onCommand() 方法在功能上是一致的，

只是前者( onStart() )在API L5以上就已经废除了， 取而代之的就是onStartCommand(), 一般后者（ onStartCommand() ）的默认实现是调用onStart(),并且返回某个值以便于与旧版本兼容。

声明周期：i>  Context.StartService() 启动一个服务， onCreate() -> onStart() 或者 onCommand() -> Context.stopService() 或者 stopSelf() -> onDestory() .

　　　　　ii> Context.bindService() 绑定一个服务，   onCreate() -> onBind() -> Context.unbindService() 或者 onUnBind() -> stioSelf() -> onDestory().

看起来又长有复杂，当你自己去用的时候会清晰很多。

实例：

package com.qimu.service;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.IBinder;
import android.os.SystemClock;
import android.util.Log;

public class QiMuService extends Service {

    qimuReceiver recevier;
    
    @Override
    public IBinder onBind(Intent intent) {
        
        return null;
    }
    
    private static final String DEBUG_TAG = "QiMu_DEBUG";
    
    public void onCreate() {

        Log.v( DEBUG_TAG, "Service starting" );
        
        recevier = new qimuReceiver();
        
        super.onCreate();
    }
    
    public void onStart( Intent intent, int startId ) {
        
        System.out.println( "Start sucess" );
        
        IntentFilter filter = new IntentFilter();
        filter.addAction("com.qimu.QiMuService");
        registerReceiver( recevier, filter );
        
        for ( int i = intent.getIntExtra( "_start", 0 ); i < 100; i++ ) {
            
            SystemClock.sleep( 200 );
            if ( i % 5 == 0) {
                System.out.println( i );
                Intent activityCallBack = new Intent();
                activityCallBack.setAction( "com.qimu.MainActivity" );
                activityCallBack.putExtra( "_time", i );
                sendBroadcast( activityCallBack );
            }
        }
        
        onDestory();
    }
    
    public int onStartCommand( Intent intent, int flags, int startId ) {

        onStart(intent, startId);
        return Service.START_REDELIVER_INTENT;
    }

    public void onDestory() {
        
        super.onDestroy();
    }
    
    public class qimuReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            //......
        }
        
    }
    
}

package com.qimu.service;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends Activity {
    
    TextView tv_service;
    qimuBroadcast broadcast;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        tv_service = ( TextView ) findViewById( R.id.service );
        
        tv_service.setOnClickListener(new View.OnClickListener() {
            
            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                //Intent serviceIntent = new Intent( MainActivity.this, com.qimu.service.QiMuService.class );
                //serviceIntent.putExtra( "_start", 1 );
                //startService( serviceIntent );
                Intent intent = new Intent("com.qimu.service.QiMuService");
                intent.putExtra("_start", 1 );
                startService(intent);
            }
        });
    }
    
    public void onStart() {

        System.out.println("Start sucess......");
        broadcast = new qimuBroadcast();
        IntentFilter intentfilter = new IntentFilter();
        intentfilter.addAction("com.qimu.MainActivity");
        registerReceiver( broadcast, intentfilter );
        super.onStart();
    }
    
    public void onStop() {
    
        unregisterReceiver( broadcast );
        super.onStop();
    }
    
    public class qimuBroadcast extends BroadcastReceiver {

        @SuppressLint("ShowToast")
        @Override
        public void onReceive( Context context, Intent intent ) {
            
            int _time = intent.getIntExtra( "_time", -1 );
            tv_service.setText( "" + _time );
        }
    }

}

书上的例子没成功，所以自己写了一个简单的Service和Activity之间通信的例子，感觉有点挫，不过大体功能是实现了，从Service的注册，创建，启动，调用BroadcastReceiver传递数据，停止，销毁都用了一遍，还是蛮简单的。

2.实现远程结构（AIDL）; 

当然你费很大功夫写了一个程序，肯定会考虑到跟其他应用程序的“交流”问题（执行其他调用），所以很明显的就会涉及到接口（远程接口）问题，AIDL就是解决这个问题的核心所在了。你要定义远程接口，首先你必须创建一个AIDL文件，在文件中声明接口，然后实现这个接口，并且在onBind()方法被调用时返回这个接口（感觉不太清楚，看代码应该是，创建了一个类来实现这个接口，返回这个类的实例）的实例。

咳咳，自己第一次做的时候连eclipse怎么创建一个AIDL文件都不知道，不过总是有好心人在某个角落留下了例子（链接:http://my.oschina.net/u/779520/blog/79936）。

接着我们就可以通过其接口来实用服务了，这时候就涉及到ServiceConnection的两个方法，onServiceConnected()和onServiceDisconnected()来实现Service的连接和释放连接（注：远程接口调用将进行跨线程的操作，并且同步完成，如果调用需要消耗比较长的时间，那么应该向其他的耗时调用一样在另外的线程中进行处理）。

注：在另外的程序中需要使用这个接口的时候，需要在工程中添加AIDL文件以及相应的包（说的普通点就是涉及到的程序中都要有这个接口文件，一个（主人家）是实现，剩下的（客人）用来调用它）。

实例：

package com.qimu.service;

interface IRemoteInterface {
    String getValue();
}

package com.qimu.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

public class Aidl_Service extends Service {

    public class aidlService extends IRemoteInterface.Stub {

        @Override
        public String getValue() throws RemoteException {
            return "Service 连接成功！";
        }
        
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        
        return new aidlService();
    }
}

package com.qimu.service;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity implements OnClickListener {
    
    TextView tv_service;
    Button bt_1, bt_2;
    private IRemoteInterface iremoteInterface = null;

    private ServiceConnection serviceconnection = new ServiceConnection() {
        
        @Override
        public void onServiceDisconnected(ComponentName arg0) {
        }
        
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

            iremoteInterface = IRemoteInterface.Stub.asInterface( service );
            bt_2.setEnabled( true );
        }
    };

    @Override
    public void onClick( View view ) {
        // TODO Auto-generated method stub
        switch ( view.getId() ) {
        
        case R.id.button1:
            
            tv_service.setText( "Service starting! " );
            bindService( new Intent("com.example.aidlservice.Aidl_Service"), serviceconnection, Context.BIND_AUTO_CREATE );
            break;
            
        case R.id.button2:
            
            try {
                tv_service.setText( iremoteInterface.getValue() );
            } catch (RemoteException e) {
                System.out.println("Error");
            }
            break;
            
        default:
            break;
        }
    }

}

很简单的一个例子，在客服端程序中有2个Button，1个TextView,点击bt_1绑定并启用服务，点击bt_2获取服务端实现的功能（返回一个字符串）。

3.实现可包装类（Parcelable）

Parcelable类主要是用来封装数据，便于传输，关于它的实用附上链接：http://blog.sina.com.cn/s/blog_78e3ae430100pxba.html，没什么太多好看的，书上提到了也就看了一下。

4.IntentService类

在程序设计中，你会需要处理很多高频率的请求，将这些需要周期性执行的任务放在一个工作队列中，会使得你的程序简单而高效，同时还可以避免创建一个完整的麻烦的Service，IntentService是一个简单的服务，它可以用Intent请求的方法来处理异步的任务，每个Intent都会被添加到与IntentService相关的工作队列中，然后序列化的进行处理，对于返回结果，你可以选择通过广播（ sendBroadcast()方法 ）向应用程序发送Intent对象，并使用应用程序中的广播接收器(BroadcastReceiver)来捕获这些结果。

实例：1中有使用......嘿嘿......

总结：Android SDK所提供的Service机制真的很强大，一个优秀的Service可以显著的增强应用程序或所提供服务的吸引力， 但是在创建实现一个后台服务的时候要很注意才行，粗糙的设计可能会对实用的移动端的性能和电池的续航能力造成本质上的影响（所以综合测试的时候要特别注意对Service的考虑）。

 第二篇，好多天了，到这里也算是结束了，收获很多很多，加油吧骚年。

期末了，要没日没夜的复习了，55555555555555555555555555.