Android四大组件完全解析（二）---Service

<!-- name是service的包名路径-->
<!-- permission定义了开启该service时所需要的权限-->
<service android:name="com.android.server.backup.KeyValueBackupJob"
                 android:permission="android.permission.BIND_JOB_SERVICE" > </service>

 public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
    }

  public final void attach(
            Context context,
            ActivityThread thread, String className, IBinder token,
            Application application, Object activityManager) {
 .........

        mStartCompatibility = getApplicationInfo().targetSdkVersion
                < Build.VERSION_CODES.ECLAIR;
    }

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

<service android:name="。。。。。"
                 android:permission="android.permission.。。。。" > </service>

 Intent intent = new Intent(Intent.ACTION_SEND);
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
                Uri.Builder b = new Uri.Builder();
                b.scheme("content");
                b.authority("com.example.android.apis.content.FileProvider");
                TypedValue tv = new TypedValue();
                getResources().getValue(R.drawable.jellies, tv, true);
                b.appendEncodedPath(Integer.toString(tv.assetCookie));
                b.appendEncodedPath(tv.string.toString());
                Uri uri = b.build();
                intent.setType("image/jpeg");
                intent.putExtra(Intent.EXTRA_STREAM, uri);
                intent.setClipData(ClipData.newUri(getContentResolver(), 
                "image",uri));
                startActivity(Intent.createChooser(intent, "Select 
                 share target"));

bindService(mBindIntent, conn,
                        Context.BIND_AUTO_CREATE | Context.BIND_ADJUST_WITH_ACTIVITY
                        | Context.BIND_WAIVE_PRIORITY)

/**
*这是一个提供本地通信的service，即进程内通信
*/
public class LocalService extends Service {
    private NotificationManager mNM;

    // Unique Identification Number for the Notification.
    // We use it on Notification start, and to cancel it.
    private int NOTIFICATION = R.string.local_service_started;

    /**
     * Class for clients to access.  Because we know this service always
     * runs in the same process as its clients, we don't need to deal with
     * IPC.
     * 该service实现的是本地的通信，即不需要跨进程，所以只需提供一个Binder实体
     * 对象供其使用即可
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            return LocalService.this;
        }
    }

    @Override
    public void onCreate() {
        mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);

        // Display a notification about us starting.  We put an icon 
        //in the status bar.
        //一旦通过start开启了service就会在状态栏进行通知
        showNotification();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("LocalService", "Received start id " + startId + ": " + intent);
        return START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        // Cancel the persistent notification.
        mNM.cancel(NOTIFICATION);

        // Tell the user we stopped.
        Toast.makeText(this, R.string.local_service_stopped, Toast.LENGTH_SHORT).show();
    }

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

    // This is the object that receives interactions from clients.  See
        // RemoteService for a more complete example.
    private final IBinder mBinder = new LocalBinder();

    /**
     * Show a notification while this service is running.
     */
    private void showNotification() {
        // In this sample, we'll use the same text for the ticker and 
        //the expanded notification
        CharSequence text = getText(R.string.local_service_started);

        // The PendingIntent to launch our activity if the user 
        //selects this notification
        //当点击该通知时启动activity
        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
                new Intent(this, LocalServiceActivities.Controller.class), 0);

        // Set the info for the views that show in the notification panel.
        Notification notification = new Notification.Builder(this)
              // the status icon设置状态栏通知图标
             .setSmallIcon(R.drawable.stat_sample)  
              // the status text设置状态栏通知文本
             .setTicker(text)  
              // the time stamp设置时间戳
             .setWhen(System.currentTimeMillis())  
             // the label of the entry下拉时显示的title      
             .setContentTitle(getText(R.string.local_service_label))  
             // the contents of the entry下拉时显示的文本
             .setContentText(text) 
             // The intent to send when the entry is clicked点击时的动作
             .setContentIntent(contentIntent) 
             .build();

        // Send the notification.
        mNM.notify(NOTIFICATION, notification);
    }
}
//END_INCLUDE(service)

 public static class Binding extends Activity {
        private boolean mIsBound;

// BEGIN_INCLUDE(bind)
        private LocalService mBoundService;

        private ServiceConnection mConnection = new ServiceConnection() {
            public void onServiceConnected(ComponentName className, IBinder service) {
                // This is called when the connection with the service has been
                // established, giving us the service object we can use to
                // interact with the service.  Because we have bound to a explicit
                // service that we know is running in our own process, we can
                // cast its IBinder to a concrete class and directly access it.
//当绑定服务时会触发该方法
                mBoundService = ((LocalService.LocalBinder)service).getService();

                // Tell the user about this for our demo.
                Toast.makeText(Binding.this, R.string.local_service_connected,
                        Toast.LENGTH_SHORT).show();
            }

            public void onServiceDisconnected(ComponentName className) {
                // This is called when the connection with the service has been
                // unexpectedly disconnected -- that is, its process crashed.
                // Because it is running in our same process, we should never
                // see this happen.
                mBoundService = null;
                Toast.makeText(Binding.this, R.string.local_service_disconnected,
                        Toast.LENGTH_SHORT).show();
            }
        };

        void doBindService() {
            // Establish a connection with the service.  We use an explicit
            // class name because we want a specific service implementation that
            // we know will be running in our own process (and thus won't be
            // supporting component replacement by other applications).
            bindService(new Intent(Binding.this, 
                    LocalService.class), mConnection, Context.BIND_AUTO_CREATE);
            mIsBound = true;
        }

        void doUnbindService() {
            if (mIsBound) {
                // Detach our existing connection.
                unbindService(mConnection);
                mIsBound = false;
            }
        }

        @Override
        protected void onDestroy() {
            super.onDestroy();
            doUnbindService();
        }
// END_INCLUDE(bind)

        private OnClickListener mBindListener = new OnClickListener() {
            public void onClick(View v) {
                doBindService();
            }
        };

        private OnClickListener mUnbindListener = new OnClickListener() {
            public void onClick(View v) {
                doUnbindService();
            }
        };

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            setContentView(R.layout.local_service_binding);

            // Watch for button clicks.
            Button button = (Button)findViewById(R.id.bind);
            button.setOnClickListener(mBindListener);
            button = (Button)findViewById(R.id.unbind);
            button.setOnClickListener(mUnbindListener);
        }
    }

 public static class Controller extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            setContentView(R.layout.local_service_controller);

            // Watch for button clicks.
            Button button = (Button)findViewById(R.id.start);
            button.setOnClickListener(mStartListener);
            button = (Button)findViewById(R.id.stop);
            button.setOnClickListener(mStopListener);
        }

        private OnClickListener mStartListener = new OnClickListener() {
            public void onClick(View v) {
                // Make sure the service is started.  It will continue running
                // until someone calls stopService().  The Intent we use to find
                // the service explicitly specifies our service component, because
                // we want it running in our own process and don't want other
                // applications to replace it.
                startService(new Intent(Controller.this,
                        LocalService.class));
            }
        };

        private OnClickListener mStopListener = new OnClickListener() {
            public void onClick(View v) {
                // Cancel a previous call to startService().  Note that the
                // service will not actually stop at this point if there are
                // still bound clients.
                stopService(new Intent(Controller.this,
                        LocalService.class));
            }
        };
    }

public class RemoteService extends Service {


    static class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what){
                case 0:
                    Log.i("fang","客户端绑定啦~~");
                    Message message = Message.obtain();
                    try {
                        msg.replyTo.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    break;
            }
        }
    }

    final static Messenger messenger = new Messenger(new IncomingHandler());
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }
}

public class RemoteServiceActivities {

    /**
     * 绑定服务
     */
    public static class BindServiceActivity extends Activity implements View.OnClickListener{

        private boolean mIsBound ;
        private Messenger mService = null;
        private static class IncomingHandler extends Handler{
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Log.i("fang","接收到服务器端消息啦~~");
            }
        }

        private Messenger messenger = new Messenger(new IncomingHandler());
        private ServiceConnection connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                //获取到binder
                mService = new Messenger(service);
                Message message = Message.obtain(null,0);
                //给service传递messenger用于信息返回
                message.replyTo = messenger;
                try {
                    mService.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                mService = null;
            }
        };
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.bind);
            initView();
        }

        void initView(){
            TextView bind = (TextView) findViewById(R.id.bind);
            TextView unbind = (TextView) findViewById(R.id.unbind);
            setClickListener(bind,unbind);
        }

        void setClickListener(View...views){
            for (View view:views) {
                if (view != null){
                    view.setOnClickListener(this);
                }
            }
        }

        void doBindService(){
            Intent intent = new Intent("com.android.zrf.remoteservice");
            bindService(intent,connection,BIND_AUTO_CREATE);
            mIsBound = true;
        }

        void doUnbindService(){
            if (mIsBound){
                mIsBound = false;
                unbindService(connection);
            }
        }
        @Override
        public void onClick(View v) {
            switch (v.getId()){
                case R.id.bind:
                    doBindService();
                    break;
                case R.id.unbind:
                    doUnbindService();
                    break;
            }
        }
    }

    /**
     * 开启服务
     */
    public static class StartServiceActivity extends Activity implements View.OnClickListener{
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.start);
            initView();
        }

        void initView(){
            TextView start = (TextView) findViewById(R.id.start);
            TextView stop = (TextView) findViewById(R.id.stop);
            setClickListener(start,stop);
        }

        void setClickListener(View...views){
            for (View view:views) {
                if (view != null){
                    view.setOnClickListener(this);
                }
            }
        }
        void  startService(){
            Intent intent = new Intent(StartServiceActivity.this,LocalService.class);
            startService(intent);
        }

        void stopService(){
            Intent intent = new Intent(StartServiceActivity.this,LocalService.class);
            stopService(intent);
        }

        @Override
        public void onClick(View v) {
            switch (v.getId()){
                case R.id.start:
                    startService();
                    break;
                case R.id.stop:
                    stopService();
                    break;
            }
        }
    }
}