Context类bindService(Intent service, ServiceConnection conn, int flags)参数

 public abstract boolean bindService(Intent service, ServiceConnection conn, int flags);

参数 flags的值有如下情况：

1. public static final int BIND_AUTO_CREATE       表明只要绑定存在，就自动建立 Service；同时也告知Android系统，这个Service的重要程度与调用者相同， 除非考虑终止调用者，否则不要关闭这个Service
2. public static final int BIND_DEBUG_UNBIND
3. public static final int BIND_NOT_FOREGROUND
4. public static final int BIND_ABOVE_CLIENT
5. public static final int BIND_WAIVE_PRIORITY

bindService()是Context的一个方法，它是抽象的。函数原型的代码如下：（android 2.3.3）

  * This function will throw {@link SecurityException} if you do not
  * have permission to bind to the given service.
  *
  * Note: this method can not be called from an
  * {@link BroadcastReceiver} component.  A pattern you can use to
  * communicate from an BroadcastReceiver to a Service is to call
  * {@link #startService} with the arguments containing the command to be
  * sent, with the service calling its
  * {@link android.app.Service#stopSelf(int)} method when done executing
  * that command.  See the API demo App/Service/Service Start Arguments
  * Controller for an illustration of this.  It is okay, however, to use
  * this method from an BroadcastReceiver that has been registered with
  * {@link #registerReceiver}, since the lifetime of this BroadcastReceiver
  * is tied to another object (the one that registered it).
  *
  * @param service Identifies the service to connect to.  The Intent may
  *      specify either an explicit component name, or a logical
  *      description (action, category, etc) to match an
  *      {@link IntentFilter} published by a service.
  * @param conn Receives information as the service is started and stopped.
  * @param flags Operation options for the binding.  May be 0,
  *          {@link #BIND_AUTO_CREATE}, {@link #BIND_DEBUG_UNBIND}, or
  *          {@link #BIND_NOT_FOREGROUND}.
  * @return If you have successfully bound to the service, true is returned;
  *         false is returned if the connection is not made so you will not
  *         receive the service object.
  *
  * @throws SecurityException
  *
  * @see #unbindService
  * @see #startService
  * @see #BIND_AUTO_CREATE
  * @see #BIND_DEBUG_UNBIND
  * @see #BIND_NOT_FOREGROUND
  */
 public abstract boolean bindService(Intent service, ServiceConnection conn,  int flags);

而最终实现bindService()方法的是ContextImpl这个类，代码如下：

 @Override
     public boolean bindService(Intent service, ServiceConnection conn,
             int flags) {
         IServiceConnection sd;
         if (mPackageInfo != null) {
             sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(),
                     mMainThread.getHandler(), flags);
         } else {
             throw new RuntimeException("Not supported in system context");
         }
         try {
             int res = ActivityManagerNative.getDefault().bindService(
                 mMainThread.getApplicationThread(), getActivityToken(),
                 service, service.resolveTypeIfNeeded(getContentResolver()),
                 sd, flags);
             if (res < 0) {
                 throw new SecurityException(
                         "Not allowed to bind to service " + service);
             }
             return res != 0;
         } catch (RemoteException e) {
             return false;
         }
     }

这里暂且不讨论是如何实现bindService()的。

 public abstract boolean bindService(Intent service, ServiceConnection conn, int flags);

从函数原型可知，bindService()有3个参数，官方文档解释如下：

service	Identifies the service to connect to. The Intent may specify either an explicit component name, or a logical description (action, category, etc) to match an IntentFilter published by a service.
conn	Receives information as the service is started and stopped. This must be a valid ServiceConnection object; it must not be null.
flags	Operation options for the binding. May be 0, BIND_AUTO_CREATE, BIND_DEBUG_UNBIND, BIND_NOT_FOREGROUND, BIND_ABOVE_CLIENT,BIND_ALLOW_OOM_MANAGEMENT, or BIND_WAIVE_PRIORITY.

service和conn比较好理解。flags意思是绑定时的选项，可以有很多选项，一一来看。

public static final int BIND_AUTO_CREATE

Added in  API level 1

Flag for bindService(Intent, ServiceConnection, int): automatically create the service as long as the binding exists. Note that while this will create the service, its onStartCommand(Intent, int, int) method will still only be called due to an explicit call to startService(Intent). Even without that, though, this still provides you with access to the service object while the service is created.

Note that prior to ICE_CREAM_SANDWICH, not supplying this flag would also impact how important the system consider's the target service's process to be. When set, the only way for it to be raised was by binding from a service in which case it will only be important when that activity is in the foreground. Now to achieve this behavior you must explicitly supply the new flag BIND_ADJUST_WITH_ACTIVITY. For compatibility, old applications that don't specifyBIND_AUTO_CREATE will automatically have the flags BIND_WAIVE_PRIORITY and BIND_ADJUST_WITH_ACTIVITY set for them in order to achieve the same result.

Constant Value: 1 (0x00000001)

public static final int BIND_DEBUG_UNBIND

Added in  API level 1

Flag for bindService(Intent, ServiceConnection, int): include debugging help for mismatched calls to unbind. When this flag is set, the callstack of the following unbindService(ServiceConnection) call is retained, to be printed if a later incorrect unbind call is made. Note that doing this requires retaining information about the binding that was made for the lifetime of the app, resulting in a leak -- this should only be used for debugging.

Constant Value: 2 (0x00000002)

public static final int BIND_NOT_FOREGROUND

Added in  API level 8

Flag for bindService(Intent, ServiceConnection, int): don't allow this binding to raise the target service's process to the foreground scheduling priority. It will still be raised to at least the same memory priority as the client (so that its process will not be killable in any situation where the client is not killable), but for CPU scheduling purposes it may be left in the background. This only has an impact in the situation where the binding client is a foreground process and the target service is in a background process.

Constant Value: 4 (0x00000004)

public static final int BIND_ABOVE_CLIENT

Added in  API level 14

Flag for bindService(Intent, ServiceConnection, int): indicates that the client application binding to this service considers the service to be more important than the app itself. When set, the platform will try to have the out of memory killer kill the app before it kills the service it is bound to, though this is not guaranteed to be the case.

Constant Value: 8 (0x00000008)

public static final int BIND_ALLOW_OOM_MANAGEMENT

Added in  API level 14

Flag for bindService(Intent, ServiceConnection, int): allow the process hosting the bound service to go through its normal memory management. It will be treated more like a running service, allowing the system to (temporarily) expunge the process if low on memory or for some other whim it may have, and being more aggressive about making it a candidate to be killed (and restarted) if running for a long time.

Constant Value: 16 (0x00000010)

public static final int BIND_WAIVE_PRIORITY

Added in  API level 14

Flag for bindService(Intent, ServiceConnection, int): don't impact the scheduling or memory management priority of the target service's hosting process. Allows the service's process to be managed on the background LRU list just like a regular application process in the background.

Constant Value: 32 (0x00000020)

常量源码android 2.3.3

 /**
  * Flag for {@link #bindService}: automatically create the service as long
  * as the binding exists.  Note that while this will create the service,
  * its {@link android.app.Service#onStartCommand}
  * method will still only be called due to an
  * explicit call to {@link #startService}.  Even without that, though,
  * this still provides you with access to the service object while the
  * service is created.
  *
  * Specifying this flag also tells the system to treat the service
  * as being as important as your own process -- that is, when deciding
  * which process should be killed to free memory, the service will only
  * be considered a candidate as long as the processes of any such bindings
  * is also a candidate to be killed.  This is to avoid situations where
  * the service is being continually created and killed due to low memory.
  */
 public static final int BIND_AUTO_CREATE = 0x0001;

 /**
  * Flag for {@link #bindService}: include debugging help for mismatched
  * calls to unbind.  When this flag is set, the callstack of the following
  * {@link #unbindService} call is retained, to be printed if a later
  * incorrect unbind call is made.  Note that doing this requires retaining
  * information about the binding that was made for the lifetime of the app,
  * resulting in a leak -- this should only be used for debugging.
  */
 public static final int BIND_DEBUG_UNBIND = 0x0002;

 /**
  * Flag for {@link #bindService}: don't allow this binding to raise
  * the target service's process to the foreground scheduling priority.
  * It will still be raised to the at least the same memory priority
  * as the client (so that its process will not be killable in any
  * situation where the client is not killable), but for CPU scheduling
  * purposes it may be left in the background.  This only has an impact
  * in the situation where the binding client is a foreground process
  * and the target service is in a background process.
  */
 public static final int BIND_NOT_FOREGROUND = 0x0004;