精华内容
参与话题
问答
  • StartService

    千次阅读 2005-06-07 12:04:00
    StartServiceThe StartService function starts a service.BOOL StartService( SC_HANDLE hService, DWORD dwNumServiceArgs, LPCTSTR* lpServiceArgVectors);ParametershService [in] Handle to the s

    StartService

    The StartService function starts a service.

    BOOL StartService(
      SC_HANDLE ,
      DWORD ,
      LPCTSTR* 
    );
    

    Parameters

    hService
    [in] Handle to the service. This handle is returned by the OpenService or CreateService function, and it must have the SERVICE_START access right. For more information, see Service Security and Access Rights.
    dwNumServiceArgs
    [in] Number of strings in the lpServiceArgVectors array. If lpServiceArgVectors is NULL, this parameter can be zero.
    lpServiceArgVectors
    [in] Pointer to an array of pointers to null-terminated strings to be passed to a service as arguments. Driver services do not receive these arguments. If no arguments are passed to the service, this parameter can be NULL. The service accesses these arguments through its ServiceMain function. The first argument (argv[0]) is the name of the service by default, followed by the arguments, if any, in the lpServiceArgVectors array.

    Return Values

    If the function succeeds, the return value is nonzero.

    If the function fails, the return value is zero. To get extended error information, call GetLastError.

    The following error codes can be set by the service control manager. Others can be set by the registry functions that are called by the service control manager.

    Return codeDescription
    ERROR_ACCESS_DENIEDThe handle does not have the SERVICE_START access right.
    ERROR_INVALID_HANDLEThe handle is invalid.
    ERROR_PATH_NOT_FOUNDThe service binary file could not be found.
    ERROR_SERVICE_ALREADY_RUNNINGAn instance of the service is already running.
    ERROR_SERVICE_DATABASE_LOCKEDThe database is locked.
    ERROR_SERVICE_DEPENDENCY_DELETEDThe service depends on a service that does not exist or has been marked for deletion.
    ERROR_SERVICE_DEPENDENCY_FAILThe service depends on another service that has failed to start.
    ERROR_SERVICE_DISABLEDThe service has been disabled.
    ERROR_SERVICE_LOGON_FAILEDThe service did not start due to a logon failure. This error occurs if the service is configured to run under an account that does not have the "Log on as a service" right.
    ERROR_SERVICE_MARKED_FOR_DELETEThe service has been marked for deletion.
    ERROR_SERVICE_NO_THREADA thread could not be created for the service.
    ERROR_SERVICE_REQUEST_TIMEOUTThe process for the service was started, but it did not call StartServiceCtrlDispatcher, or the thread that called StartServiceCtrlDispatcher may be blocked in a control handler function.

    Remarks

    When a driver service is started, the StartService function does not return until the device driver has finished initializing.

    When a service is started, the Service Control Manager (SCM) spawns the service process, if necessary. If the specified service shares a process with other services, the required process may already exist. The StartService function does not wait for the first status update from the new service, because it can take a while. Instead, it returns when the SCM receives notification from the service control dispatcher that the ServiceMain thread for this service was created successfully.

    The SCM sets the following default status values before returning from StartService:

    • Current state of the service is set to SERVICE_START_PENDING.
    • Controls accepted is set to none (zero).
    • The CheckPoint value is set to zero.
    • The WaitHint time is set to 2 seconds.

    The calling process can determine if the new service has finished its initialization by calling the QueryServiceStatus function periodically to query the service's status.

    A service cannot call StartService during initialization. The reason is that the SCM locks the service control database during initialization, so a call to StartService will block. Once the service reports to the SCM that it has successfully started, it can call StartService.

    As with ControlService, StartService will block for 30 seconds if any service is busy handling a control code. If the busy service still has not returned from its handler function when the timeout expires, StartService fails with ERROR_SERVICE_REQUEST_TIMEOUT. This is because the SCM processes only one service control notification at a time.

    Example Code

    For an example, see Starting a Service.

    Requirements

    ClientRequires Windows XP, Windows 2000 Professional, or Windows NT Workstation.
    ServerRequires Windows Server 2003, Windows 2000 Server, or Windows NT Server.
    Header

    Declared in Winsvc.h; include Windows.h.

    Library

    Link to Advapi32.lib.

    DLLRequires Advapi32.dll.
    Unicode

    Implemented as StartServiceW (Unicode) and StartServiceA (ANSI).

    展开全文
  • startService与bindService的区别

    万次阅读 2016-05-21 16:46:15
    Android执行Service有两种方法,一种是startService,一种是bindService。下面让我们一起来聊一聊这两种执行Service方法的区别。 1、生命周期上的区别执行startService时,Service会经历onCreate->onStartCommand...

    Android执行Service有两种方法,一种是startService,一种是bindService。下面让我们一起来聊一聊这两种执行Service方法的区别。
    这里写图片描述

    1、生命周期上的区别

    执行startService时,Service会经历onCreate->onStartCommand。当执行stopService时,直接调用onDestroy方法。调用者如果没有stopService,Service会一直在后台运行,下次调用者再起来仍然可以stopService。

    执行bindService时,Service会经历onCreate->onBind。这个时候调用者和Service绑定在一起。调用者调用unbindService方法或者调用者Context不存在了(如Activity被finish了),Service就会调用onUnbind->onDestroy。这里所谓的绑定在一起就是说两者共存亡了。

    多次调用startService,该Service只能被创建一次,即该Service的onCreate方法只会被调用一次。但是每次调用startService,onStartCommand方法都会被调用。Service的onStart方法在API 5时被废弃,替代它的是onStartCommand方法。

    第一次执行bindService时,onCreate和onBind方法会被调用,但是多次执行bindService时,onCreate和onBind方法并不会被多次调用,即并不会多次创建服务和绑定服务。

    2、调用者如何获取绑定后的Service的方法

    onBind回调方法将返回给客户端一个IBinder接口实例,IBinder允许客户端回调服务的方法,比如得到Service运行的状态或其他操作。我们需要IBinder对象返回具体的Service对象才能操作,所以说具体的Service对象必须首先实现Binder对象。

    3、既使用startService又使用bindService的情况

    如果一个Service又被启动又被绑定,则该Service会一直在后台运行。首先不管如何调用,onCreate始终只会调用一次。对应startService调用多少次,Service的onStart方法便会调用多少次。Service的终止,需要unbindService和stopService同时调用才行。不管startService与bindService的调用顺序,如果先调用unbindService,此时服务不会自动终止,再调用stopService之后,服务才会终止;如果先调用stopService,此时服务也不会终止,而再调用unbindService或者之前调用bindService的Context不存在了(如Activity被finish的时候)之后,服务才会自动停止。

    那么,什么情况下既使用startService,又使用bindService呢?

    如果你只是想要启动一个后台服务长期进行某项任务,那么使用startService便可以了。如果你还想要与正在运行的Service取得联系,那么有两种方法:一种是使用broadcast,另一种是使用bindService。前者的缺点是如果交流较为频繁,容易造成性能上的问题,而后者则没有这些问题。因此,这种情况就需要startService和bindService一起使用了。

    另外,如果你的服务只是公开一个远程接口,供连接上的客户端(Android的Service是C/S架构)远程调用执行方法,这个时候你可以不让服务一开始就运行,而只是bindService,这样在第一次bindService的时候才会创建服务的实例运行它,这会节约很多系统资源,特别是如果你的服务是远程服务,那么效果会越明显(当然在Servcie创建的是偶会花去一定时间,这点需要注意)。

    4、本地服务与远程服务

    本地服务依附在主进程上,在一定程度上节约了资源。本地服务因为是在同一进程,因此不需要IPC,也不需要AIDL。相应bindService会方便很多。缺点是主进程被kill后,服务变会终止。

    远程服务是独立的进程,对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程,因此在Activity所在进程被kill的是偶,该服务依然在运行。缺点是该服务是独立的进程,会占用一定资源,并且使用AIDL进行IPC稍微麻烦一点。

    对于startService来说,不管是本地服务还是远程服务,我们需要做的工作都一样简单。

    5、代码实例

    startService启动服务

    public class LocalService1 extends Service {
        /**
        * onBind 是 Service 的虚方法,因此我们不得不实现它。
        * 返回 null,表示客服端不能建立到此服务的连接。
        */
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
        
        @Override
        public void onCreate() {
            super.onCreate();
        }
        
        @Override
        public void onStartCommand(Intent intent, int startId, int flags) {
            super.onStartCommand(intent, startId, flags);
        }
        
        @Override
        public void onDestroy() {
            super.onDestroy();
        }
    }
    

    bindService绑定服务

    public class LocalService extends Service {
    /**
    * 在 Local Service 中我们直接继承 Binder 而不是 IBinder,因为 Binder 实现了 IBinder 接口,这样我们可以** 少做很多工作。
    */
    public class SimpleBinder extends Binder{
    /**
    * 获取 Service 实例
    * @return
    */
    public LocalService getService(){
    return LocalService.this;
    }
    
    public int add(int a, int b){
    return a + b;
    }
    }
    
    public SimpleBinder sBinder;
    
    @Override
    public void onCreate() {
    super.onCreate();
    // 创建 SimpleBinder
    sBinder = new SimpleBinder();
    }
    
    @Override
    public IBinder onBind(Intent intent) {
    // 返回 SimpleBinder 对象
    return sBinder;
    }
    }
    

    上面的代码关键之处,在于 onBind(Intent) 这个方法 返回了一个实现了 IBinder 接口的对象,这个对象将用于绑定Service 的 Activity 与 Local Service 通信。

    下面是 Activity 中的代码:

    public class Main extends Activity {
        private final static String TAG = "SERVICE_TEST";
        private ServiceConnection sc;
        private boolean isBind;
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            sc = new ServiceConnection() {
                @Override
                public void onServiceDisconnected(ComponentName name) {
                }
        
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    LocalService.SimpleBinder sBinder = (LocalService.SimpleBinder)service;
                    Log.v(TAG, "3 + 5 = " + sBinder.add(3, 5));
                    Log.v(TAG, sBinder.getService().toString());
                }
            };
    
            findViewById(R.id.btnBind).setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    bindService(new Intent(Main.this, LocalService.class), sc, Context.BIND_AUTO_CREATE);
                    isBind = true;
                }
            });
    
            findViewById(R.id.btnUnbind).setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    if(isBind){
                        unbindService(sc);
                        isBind = false;
                    }
                }
            });
        }
    }
    

    6、在AndroidManifest.xml里Service元素常见选项

    android:name  -------------  服务类名
    
    android:label  --------------  服务的名字,如果此项不设置,那么默认显示的服务名则为类名
    
    android:icon  --------------  服务的图标
    
    android:permission  -------  申明此服务的权限,这意味着只有提供了该权限的应用才能控制或连接此服务
    
    android:process  ----------  表示该服务是否运行在另外一个进程,如果设置了此项,那么将会在包名后面加上这段字符串表示另一进程的名字
    
    android:enabled  ----------  表示是否能被系统实例化,为true表示可以,为false表示不可以,默认为true
    
    android:exported  ---------  表示该服务是否能够被其他应用程序所控制或连接,不设置默认此项为 false
    

    转载地址:
    http://my.oschina.net/tingzi/blog/376545


    如有错误欢迎指出来,一起学习。
    在这里插入图片描述

    展开全文
  • StartService总结

    千次阅读 2013-08-25 10:14:20
    介绍了StartService相关知识点。

    一、整体工程图



    二、activity_start_service.xml

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
      xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"
      android:orientation="vertical">
    
    
    <Button android:text="startService" 
        android:id="@+id/buttonStartService" 
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"></Button>
    </LinearLayout>
    


    三、AndroidManifest.xml,需要注册Service

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.jltxgcy.startservicedemo"
        android:versionCode="1"
        android:versionName="1.0" >
    
        <uses-sdk
            android:minSdkVersion="8"
            android:targetSdkVersion="15" />
    
        <application
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            <activity
                android:name=".StartServiceActivity"
                android:label="@string/title_activity_start_service" >
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
            <service
                android:name=".HelloService">
            </service>
                
        </application>
    
    </manifest>

    四、StartServiceActivity.java

    package com.jltxgcy.startservicedemo;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.View;
    import android.view.View.OnClickListener;
    
    public class StartServiceActivity extends Activity {
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_start_service);
            
            findViewById(R.id.buttonStartService).setOnClickListener(new OnClickListener() {
    			
    			@Override
    			public void onClick(View v) {
    				Intent intent = new Intent(StartServiceActivity.this,HelloService.class);
    				startService(intent);
    			}
    		});
        }
    
    
    }

    五、HelloService.java

    package com.jltxgcy.startservicedemo;
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.os.IBinder;
    import android.os.Looper;
    import android.os.Message;
    import android.util.Log;
    import android.widget.Toast;
    import android.os.Process;
    
    public class HelloService extends Service {
    
    	  private Looper mServiceLooper;
    	  private ServiceHandler mServiceHandler;
    	  public static final String TAG="jltxgcy";
    
    
    	  private final class ServiceHandler extends Handler {
    	      public ServiceHandler(Looper looper) {
    	          super(looper);
    	      }
    	      @Override
    	      public void handleMessage(Message msg) {
    	    	  Log.d(TAG, "handleMessage"+Thread.currentThread().getId());
    	          long endTime = System.currentTimeMillis() + 5*1000;
    	          while (System.currentTimeMillis() < endTime) {
    	              synchronized (this) {
    	                  try {
    	                      wait(endTime - System.currentTimeMillis());
    	                  } catch (Exception e) {
    	                  }
    	              }
    	          }
    
    	          stopSelf(msg.arg1);
    	      }
    	  }
    
    	  @Override
    	  public void onCreate() {
    
    	    HandlerThread thread = new HandlerThread("ServiceStartArguments",
    	            Process.THREAD_PRIORITY_BACKGROUND);
    	    thread.start();
    
    	    mServiceLooper = thread.getLooper();
    	    mServiceHandler = new ServiceHandler(mServiceLooper);
    	  }
    
    	  @Override
    	  public int onStartCommand(Intent intent, int flags, int startId) {
    	      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    	      Message msg = mServiceHandler.obtainMessage();
    	      msg.arg1 = startId;
    	      Log.d(TAG, "onStartCommand"+Thread.currentThread().getId());
    	      mServiceHandler.sendMessage(msg);
    	      return START_STICKY;
    	  }
    
    	  @Override
    	  public IBinder onBind(Intent intent) {
    	      return null;
    	  }
    	  
    	  @Override
    	  public void onDestroy() {
    	    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show(); 
    	  }
    }

    六、解析

            按下startService,回调用onCreate,onStartCommand,Logcat显示如下:

            

            说明onStartCommand在主线程中,handleMessage通过Handler起了一个新的线程完成下载工作,下载工作完成后调用stopSelf

    来停止Service,此时调用onDestroy方法。

             第二次点击startService,就只会调用onStartCommand,不会调用onCreate了。

             一般用于后台下载任务,或者当Activity退出后,Service来播放音乐。

             代码地址:https://github.com/jltxgcy/Demo


    展开全文
  • startService bindService 区别

    千次阅读 2018-05-13 07:27:58
    Android执行Service有两种方法,一种是startService,一种是bindService。下面让我们一起来聊一聊这两种执行Service方法的区别。 1、生命周期上的区别执行startService时,Service会经历onCreate-&gt;...

    Android执行Service有两种方法,一种是startService,一种是bindService。下面让我们一起来聊一聊这两种执行Service方法的区别。 
    这里写图片描述

    1、生命周期上的区别

    执行startService时,Service会经历onCreate->onStartCommand。当执行stopService时,直接调用onDestroy方法。调用者如果没有stopService,Service会一直在后台运行,下次调用者再起来仍然可以stopService。

    执行bindService时,Service会经历onCreate->onBind。这个时候调用者和Service绑定在一起。调用者调用unbindService方法或者调用者Context不存在了(如Activity被finish了),Service就会调用onUnbind->onDestroy。这里所谓的绑定在一起就是说两者共存亡了。

    多次调用startService,该Service只能被创建一次,即该Service的onCreate方法只会被调用一次。但是每次调用startService,onStartCommand方法都会被调用。Service的onStart方法在API 5时被废弃,替代它的是onStartCommand方法。

    第一次执行bindService时,onCreate和onBind方法会被调用,但是多次执行bindService时,onCreate和onBind方法并不会被多次调用,即并不会多次创建服务和绑定服务。

    2、调用者如何获取绑定后的Service的方法

    onBind回调方法将返回给客户端一个IBinder接口实例,IBinder允许客户端回调服务的方法,比如得到Service运行的状态或其他操作。我们需要IBinder对象返回具体的Service对象才能操作,所以说具体的Service对象必须首先实现Binder对象。

    3、既使用startService又使用bindService的情况

    如果一个Service又被启动又被绑定,则该Service会一直在后台运行。首先不管如何调用,onCreate始终只会调用一次。对应startService调用多少次,Service的onStart方法便会调用多少次。Service的终止,需要unbindService和stopService同时调用才行。不管startService与bindService的调用顺序,如果先调用unbindService,此时服务不会自动终止,再调用stopService之后,服务才会终止;如果先调用stopService,此时服务也不会终止,而再调用unbindService或者之前调用bindService的Context不存在了(如Activity被finish的时候)之后,服务才会自动停止。

    那么,什么情况下既使用startService,又使用bindService呢?

    如果你只是想要启动一个后台服务长期进行某项任务,那么使用startService便可以了。如果你还想要与正在运行的Service取得联系,那么有两种方法:一种是使用broadcast,另一种是使用bindService。前者的缺点是如果交流较为频繁,容易造成性能上的问题,而后者则没有这些问题。因此,这种情况就需要startService和bindService一起使用了。

    另外,如果你的服务只是公开一个远程接口,供连接上的客户端(Android的Service是C/S架构)远程调用执行方法,这个时候你可以不让服务一开始就运行,而只是bindService,这样在第一次bindService的时候才会创建服务的实例运行它,这会节约很多系统资源,特别是如果你的服务是远程服务,那么效果会越明显(当然在Servcie创建的是偶会花去一定时间,这点需要注意)。

    4、本地服务与远程服务

    本地服务依附在主进程上,在一定程度上节约了资源。本地服务因为是在同一进程,因此不需要IPC,也不需要AIDL。相应bindService会方便很多。缺点是主进程被kill后,服务变会终止。

    远程服务是独立的进程,对应进程名格式为所在包名加上你指定的android:process字符串。由于是独立的进程,因此在Activity所在进程被kill的是偶,该服务依然在运行。缺点是该服务是独立的进程,会占用一定资源,并且使用AIDL进行IPC稍微麻烦一点。

    对于startService来说,不管是本地服务还是远程服务,我们需要做的工作都一样简单。

    5、代码实例

    startService启动服务

    public class LocalService1 extends Service {
        /**
        * onBind 是 Service 的虚方法,因此我们不得不实现它。
        * 返回 null,表示客服端不能建立到此服务的连接。
        */
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
        }
    
        @Override
        public void onStartCommand(Intent intent, int startId, int flags) {
            super.onStartCommand(intent, startId, flags);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    bindService绑定服务

    public class LocalService extends Service {
    /**
    * 在 Local Service 中我们直接继承 Binder 而不是 IBinder,因为 Binder 实现了 IBinder 接口,这样我们可以** 少做很多工作。
    */
    public class SimpleBinder extends Binder{
    /**
    * 获取 Service 实例
    * @return
    */
    public LocalService getService(){
    return LocalService.this;
    }
    
    public int add(int a, int b){
    return a + b;
    }
    }
    
    public SimpleBinder sBinder;
    
    @Override
    public void onCreate() {
    super.onCreate();
    // 创建 SimpleBinder
    sBinder = new SimpleBinder();
    }
    
    @Override
    public IBinder onBind(Intent intent) {
    // 返回 SimpleBinder 对象
    return sBinder;
    }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    上面的代码关键之处,在于 onBind(Intent) 这个方法 返回了一个实现了 IBinder 接口的对象,这个对象将用于绑定Service 的 Activity 与 Local Service 通信。

    下面是 Activity 中的代码:

    public class Main extends Activity {
        private final static String TAG = "SERVICE_TEST";
        private ServiceConnection sc;
        private boolean isBind;
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            sc = new ServiceConnection() {
                @Override
                public void onServiceDisconnected(ComponentName name) {
                }
    
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    LocalService.SimpleBinder sBinder = (LocalService.SimpleBinder)service;
                    Log.v(TAG, "3 + 5 = " + sBinder.add(3, 5));
                    Log.v(TAG, sBinder.getService().toString());
                }
            };
    
            findViewById(R.id.btnBind).setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    bindService(new Intent(Main.this, LocalService.class), sc, Context.BIND_AUTO_CREATE);
                    isBind = true;
                }
            });
    
            findViewById(R.id.btnUnbind).setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    if(isBind){
                        unbindService(sc);
                        isBind = false;
                    }
                }
            });
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    6、在AndroidManifest.xml里Service元素常见选项

    android:name  -------------  服务类名
    
    android:label  --------------  服务的名字,如果此项不设置,那么默认显示的服务名则为类名
    
    android:icon  --------------  服务的图标
    
    android:permission  -------  申明此服务的权限,这意味着只有提供了该权限的应用才能控制或连接此服务
    
    android:process  ----------  表示该服务是否运行在另外一个进程,如果设置了此项,那么将会在包名后面加上这段字符串表示另一进程的名字
    
    android:enabled  ----------  表示是否能被系统实例化,为true表示可以,为false表示不可以,默认为true
    
    android:exported  ---------  表示该服务是否能够被其他应用程序所控制或连接,不设置默认此项为 false
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    转载地址: 

    http://my.oschina.net/tingzi/blog/376545

    Android startservice & bindservice的区别

    作为一个android开发者,service大家应该已经接触过了,接触Android的第一节课,就是将Android的四大组件,那么作为四大组件之一的service,你是否足够了解呢?

    1. service和thread的区别你是否知道?service真的能执行长时间的后台操作么?

    2. 你是否知道startservice和bindservice的区别呢?

    3. service的生命周期,我们是否应该主动结束一个service呢?service是否会导致内存泄露呢?

    4. service与intentservice的区别是什么?

    上边是关于service的一些问题,问题1,我们已经在之前的博客上讲解过,详细内容见博客http://blog.csdn.net/u014088294/article/details/49907385

    关于问题4,也可以参考我们之前的文章 ,http://blog.csdn.net/u014088294/article/details/44279399

    我们主要解答问题2,startservice与bindservice的区别。

    Developer上提到,service主要有两种形式,

    1. started
    2. bound

    上边的started呢,对应与startservice,bound对应于bindservice,他们都是启动service的方式。

    startservice

    我们可以通过startservice来启动一个service,启动后,service在后台运行。通常来说,该service是无法返回结果的(这也是与bindservice的区别之一),比如我们可以下载一个文件。 
    和startservice对应的是stopservice,我们可以来显式的结束一个service。 
    service的生命周期也比较简单,和startservice相关的有三个函数,分别是onCreate,onStartCommand,onDestory。

    当我们首次startserivce启动一个service的时候,会调用service的onCreate函数,创建该服务,然后调用onStartCommand函数,执行操作。如果我们多次通过startservice启动服务,那么onCreate只会调用一次,直接调用onStartCommand。 
    我们可以调用stopsevice来结束一个service。同样,我们也可以多次调用(第一次调用已经结束,但是后来继续调用并不会产生异常)。

    当一个service通过startservice启动后,它就独立于调用者而运行(也就是说,调用者的生命周期和它的生命周期没有关系),因此呢,service应该在任务完成的时候调用stopSelf函数或者调用者stopservice来结束该服务

    Developer上提到,当我们的service执行完的时候,为了避免消耗系统资源或电量,应该结束该service。否则,该服务将会一直运行在后台,直到设备内存不足等原因把他关闭掉。

    然而,startservice并不能解决我们所有的需求,比如,我有时候,需要service的返回结果,我需要和service交互,startservice显然不能完成。那么我们可以使用到bindservice

    bindservice

    Developer这样提到,

    A bound service offers a client-server interface that allows components to interact with the service, send requests, get results, and even do so across processes with interprocess communication (IPC).

    我们可以利用bindservice来和service绑定,绑定后,我们可以和service交互,发送请求,得到结果甚至执行IPC通信。

    那么,我们应该如何使用bindservice呢?

    1. 首先我们需要重载service的onBinder,返回一个IBinder对象。该对象是 
      调用者和serivce交互的接口。
    2. 新建一个ServiceConnection变量,该类是监听Service是否bound的接口,我们重载其onServiceConnected和onServiceDisconnected方法。onServiceConnected方法中,我们得到了Service中onBinder返回的IBinder接口。
    3. 调用bindservice来绑定服务。

    按照上边的步骤,我们的代码如下, 
    1. 重载onBinder并返回一个IBinder对象。在LocalBinder中,提供getSercive方法,返回service实例。

        public class LocalBinder extends Binder {
            MyService getService() {
                return MyService.this;
            }
        }
    
        private final IBinder mBinder = new LocalBinder();
    
        @Override
        public IBinder onBind(Intent intent) {
            Log.i(TAG, "onBind");
            return mBinder;
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    2.调用者中新建ServiceConnection接口,在onServiceConnected方法中,将IBinder对象转为LocalBinder对象,并调用其getService方法,得到Service。

        private ServiceConnection mConnection = new ServiceConnection() {
            public void onServiceConnected(ComponentName className, IBinder service) {
                mBoundService = ((MyService.LocalBinder) service).getService();
            }
    
            public void onServiceDisconnected(ComponentName className) {
                  mBoundService = null;
            }
        };
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3.调用者执行bindservice,其中mConnection为ServiceConnection接口。

    bindService(new Intent(MainActivity.this,MyService.class), mConnection, Context.BIND_AUTO_CREATE);
    • 1

    当用户执行bindservice后,bind的结果会回调mConnection接口,若bind成功,就会回调onServiceConnected方法,然后我们在此方法中,得到了Service实例,得到Service实例后,然后我们就可以和Service交互了

    我们继续完善代码,在Service的onCreate方法中,我们新建一个线程,每隔1s,计数器加1.其中count为成员变量,表示当前计数值,threadDisable表示是否service关闭。

            new Thread(new Runnable() {
                // @Override
                public void run() {
                    while (!threadDisable) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                        }
                        count++;
                        System.out.println("CountService Count is " + count);
                    }
                }
            }).start();
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    然后,我们在Service中新建一个方法,返回计数值。

        public int getCount() {
            return count;
        }
    • 1
    • 2
    • 3

    那么我们在调用者中,就可以利用上边得到的mBoundService来调用getCount方法,达到与service交互的目的。 
    项目地址,https://github.com/KingPaul/ServiceDemo


    展开全文
  • Android service 启动篇之 startService

    万次阅读 2018-08-31 16:28:10
     Android基础总结之六:Sevice 中是应用端对于service 使用的总结,其中看到启动service 需要的接口有startService 和bindService。在Android O 中又添加了一个接口api——startForegroundService。本篇主要围...
  • Android中主要有两种方式使用Service,通过调用Context的startService方法调用或调用Context的bindService方法,本文只涉及startService的调用,不涉及bindService方法 当我们通过调用了Context的startService方法后...
  • 在Service启动流程(startService)的最后,分析了在调用startService时可能存在的三种情况,本文分析第一种情况—Service已经启动。 Service启动流程(startService)中已经说明了Service已经启动时会执行函数...
  • Android4.4——service之StartService

    千次阅读 2014-10-09 21:22:58
    Activity与Service类均继承自ContextWrapper,ContextWrapper继承自Context类。 1)在frameworks/base/core/ja ...Activity和Service类中无StartService函数,ContextWrapper类的StartService函数
  • 关于Android O(8.0)之后startService报错:Not allowed to start service Intent 错误原因: Android 8.0 不再允许后台service直接通过startService方式去启动, 具体行为变更如下: 如果针对 Android 8.0 的应用...
  • startService时序图 源码解析 ActivityManagerService中的处理 ActiveServices中的处理 Service.onCreate的执行 Service.onStartCommand的执行 总结 1. Service概述 Service作为Android四大组件之一,在开发过程...
  • Android10.0 startService启动过程

    千次阅读 2020-01-05 19:25:47
    原文地址:...基于Android10.0,分析startService的启动过程 一、概述 前面已经介绍了详细介绍了管理Android四大剑客Activity、Service、Broadcast、ContentProvider的Activ...
  • Android执行Service有两种方法,一种是startService,一种是bindService。下面让我们一起来聊一聊这两种执行Service方法的区别。 1、生命周期上的区别  执行startService时,Service会经历onCreate->...
  • 1.Context.startService()方式启动 ①Context.startService()方式的生命周期: 启动时,startService –> onCreate() –> onStart()停止时,stopService –> onDestroy()如果调用者直接退出而没有停止Service,则...
  • Android服务之startService源码分析

    千次阅读 2016-07-14 17:25:56
    startService是Context的抽象方法,调用startService时,会先调用到ContextWrapper的startService方法: @Override public ComponentName startService(Intent service) { return mBase.startService(service); ...
  • Service分为两种工作状态,启动状态和绑定状态,通过调用startService()可进入启动状态,通过bindService()可进入绑定状态,本篇文章主要讲解startService()启动Service的过程。(额,android的版本还是26) 我们...
  • 如果你只是想要启动一个后台服务长期进行某项任务那么使用 startService 便可以了。 如果你想要与正在运行的 Service 取得联系,那么有两种方法,一种是使用 broadcast ,另外是使用 bindService ,前者的缺点是如果...
  • startService()方式启动的Service
  • 安卓start Service和Bind Service区别

    千次阅读 2014-01-14 17:15:09
    Android中BindService方式使用的理解 最近学习了一下Android里面的Service的应用,在BindService部分小卡了一下,主要是开始没有彻底理解...1. Started Service中使用StartService()方法来进行方法的调用,调
  • MySQL 安装失败 start service 执行失败

    千次阅读 2018-11-16 13:38:25
    start service就没有响应了,按照网上的方法,怎么也不对。这就是坑,只对一半。 以下是我用过的方法: MySQL 安装总结:Start service执行无响应或失败。  安装MySQL卸载后重新安装,每次到最后Start service...
  • 基于8.0源码解析:startService 启动过程 调用startService 后会到ContextWrapper中: @Override public ComponentName startService(Intent service) { return mBase.startService(service); } 这个mBase...
  • StartService返回值为2

    千次阅读 2017-04-24 21:04:04
    今天在调试一个程序,里面涉及到驱动加载,经过调试后发现卡在StartService这个函数上了,它的返回值一直为2,之后各种百度谷歌,却都没找到相关的解决方法,足足折腾了3个小时,又是关机重启,又是修改驱动路径,但...
  • 在Service启动流程(startService)的最后,分析了在调用startService时可能存在的三种情况,本文分析第二种情况—Service与App在同一个进程,但未启动。 Service启动流程(startService)最后已经说明,在这种...
  • Android 中 startService()启动service的过程.
  • start service失败的问题解决

    万次阅读 2014-12-12 22:34:22
    start service mysql
  • 1.Android Service的基本用法(startService启动方式生命周期) 2.Android Service与Activity之间的通信(bindService启动方式) 区别如下: 一.生命周期上的区别 startService启动服务:Service会经历onCreate()---...
  • 基于Android 6.0的源码剖析, 分析android Service启动流程,相关源码: ​ frameworks/base/services/core/java/com/android/server/am/ - ActivityManagerService.java - ActiveServices.java - ...
  • 项目开发中有遇到startService与bindService混合使用的情况,发现其对Service生命周期有很大影响,故与各位分享一下。。。 一、正常情况(应该大家都很熟了,简单介绍): (1)单独使用startService(): onCreate()-...
  • 1.仅startService和stopService配合使用,与仅bindService,unbindService配合使用时,service生命周期是比较明确的 2.当startService,stopService,bindService,unbindService时,情况稍微复杂,但是通过打log可以...

空空如也

1 2 3 4 5 ... 20
收藏数 71,909
精华内容 28,763
关键字:

startservice