精华内容
下载资源
问答
  • service两种启动方式区别

    万次阅读 2018-05-31 14:32:40
    service,中文名称是服务,服务是Android中实现程序后台运行的解决方案,它非常适合去执行那些不需要和用户交互,而且还要长期运行的任务。 服务运行不依赖于任何用户界面,即使程序切换到后台,或者用户打开另一个...

    service,中文名称是服务,服务是Android中实现程序后台运行的解决方案,它非常适合去执行那些不需要和用户交互,而且还要长期运行的任务。

    服务运行不依赖于任何用户界面,即使程序切换到后台,或者用户打开另一个应用程序,服务仍然能够保持正常运行。

    不过需要注意的是,服务并不是运行在一个独立的进程当中的,而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时,所以依赖于该进程的服务也会停止运行。

    另外,也不要被服务的后台概念所迷惑,实际上服务并不会自动开启线程,所有的代码都是默认运行在主线城当中的。也就是说,我们需要在服务的内部手动创建子线程,并在这里执行具体任务,否则就有可能出现主次线程被阻塞住的情况。

    service有两种启动方式,一种是通过 startService() 来启动的,另一种是通过 bindService() 来启动的。

    第一种:通过 startService() 来启动

    通过 startService() 来启动方式的生命周期如下:
    这里写图片描述

    使用Service的步骤如下:

    1. 定义一个类,并继承 Service
    2. 在 AndroidManifest.xml 文件中配置此 Service
    3. 使用 Context 的 startService(Intent) 方法来启动 Service
    4. 不使用该服务时,调用 stopService(Intent) 方法停止此 Service

    如果服务已经开启,就不会重复的执行 onCreate() ,而是调用 onStart() 或 onStartCommand()。而服务停止的时候调用 onDestory() 。

    特点:

    • 一旦服务开启跟开启者就没有任何关系;
    • 开启者退出之后,服务还是可以在后台长期运行的。前提是没有调用 stopService(Intent);
    • 开启者不能调用服务里面的方法


    第二种:通过 bindService() 来启动

    通过 bindService() 来启动方式的生命周期如下:
    这里写图片描述

    使用Service的步骤如下:

    1. 定义一个类,并继承 Service
    2. 在 AndroidManifest.xml 中配置此 Service
    3. 使用 Context 的 bindService(Intent, ServiceConnection, int) 方法来启动此 Service
    4. 不使用该服务时,调用 unbindService(ServiceConnection) 方法停止此 Service

    绑定服务不会调用 onStart() 或 onStartCommand() 方法。

    特点:

    • bind的方式开启服务,绑定服务,调用者挂了,服务也会跟着挂掉。
    • 绑定者可以调用服务里面的方法。
    展开全文
  • Android Service两种启动方式区别

    千次阅读 2018-05-22 18:17:26
    今天笔试题有问到Android中Service两种启动和停止方式有什么不同。所以特地来总结一下Service的知识。Service是Android四大组件之一,也是可执行的程序,有自己的生命周期。创建、配置Service和创...
    
    

    Android Service 服务的启动和停止方式

    前言:苦逼的野生程序员最近在找工作,跑了各种校园招聘。仍然没有找到Android方面的工作。哎,说多了都是泪啊,进入正题吧。今天笔试题有问到Android中Service两种启动和停止方式有什么不同。所以特地来总结一下Service的知识。

    Service是Android四大组件之一,也是可执行的程序,有自己的生命周期。创建、配置Service和创建、配置Activity的过程相似。和Activity一样,都是从Context派生出来的。 ---《疯狂android讲义(第二版)》

    一.Service的第一种启动方式

    采用start的方式开启服务

    使用Service的步骤:

    1.定义一个类继承Service
    2.在Manifest.xml文件中配置该Service
    3.使用Context的startService(Intent)方法启动该Service
    4.不再使用时,调用stopService(Intent)方法停止该服务

    使用这种start方式启动的Service的生命周期如下:
    onCreate()--->onStartCommand()onStart()方法已过时) --->onDestory()

    说明:如果服务已经开启,不会重复的执行onCreate(), 而是会调用onStart()onStartCommand()
    服务停止的时候调用 onDestory()。服务只会被停止一次。

    特点:一旦服务开启跟调用者(开启者)就没有任何关系了。
    开启者退出了,开启者挂了,服务还在后台长期的运行。
    开启者不能调用服务里面的方法。

    二.Service的第二种启动方式

    采用bind的方式开启服务

    使用Service的步骤:

    1.定义一个类继承Service
    2.在Manifest.xml文件中配置该Service
    3.使用Context的bindService(Intent, ServiceConnection, int)方法启动该Service
    4.不再使用时,调用unbindService(ServiceConnection)方法停止该服务

    使用这种start方式启动的Service的生命周期如下:
    onCreate() --->onBind()--->onunbind()--->onDestory()

    注意:绑定服务不会调用onstart()或者onstartcommand()方法

    特点:bind的方式开启服务,绑定服务,调用者挂了,服务也会跟着挂掉。
    绑定者可以调用服务里面的方法。


    到这里,两种方式的区别已经明确了。

    问题来了。
    绑定者如何调用服务里的方法呢?

    首先定义一个Service的子类。

    public class MyService extends Service {
    
        public MyService() {
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            //返回MyBind对象
            return new MyBinder();
        }
    
        private void methodInMyService() {
            Toast.makeText(getApplicationContext(), "服务里的方法执行了。。。",
                    Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 该类用于在onBind方法执行后返回的对象,
         * 该对象对外提供了该服务里的方法
         */
        private class MyBinder extends Binder implements IMyBinder {
    
            @Override
            public void invokeMethodInMyService() {
                methodInMyService();
            }
        }
    }
    

    自定义的MyBinder接口用于保护服务中不想让外界访问的方法。

    public interface IMyBinder {
    
         void invokeMethodInMyService();
    
    }
    

    接着在Manifest.xml文件中配置该Service

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

    在Activity中绑定并调用服务里的方法
    简单布局:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="start"
            android:text="开启服务"
            android:textSize="30sp" />
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="invoke"
            android:text="调用服务的方法"
            android:textSize="30sp" />
    </LinearLayout>
    

    绑定服务的Activity:

    public class MainActivity extends Activity {
    
        private MyConn conn;
        private Intent intent;
        private IMyBinder myBinder;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        //开启服务按钮的点击事件
        public void start(View view) {
            intent = new Intent(this, MyService.class);
            conn = new MyConn();
            //绑定服务,
            // 第一个参数是intent对象,表面开启的服务。
            // 第二个参数是绑定服务的监听器
            // 第三个参数一般为BIND_AUTO_CREATE常量,表示自动创建bind
            bindService(intent, conn, BIND_AUTO_CREATE);
        }
    
        //调用服务方法按钮的点击事件
        public void invoke(View view) {
            myBinder.invokeMethodInMyService();
        }
    
        private class MyConn implements ServiceConnection {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                //iBinder为服务里面onBind()方法返回的对象,所以可以强转为IMyBinder类型
                myBinder = (IMyBinder) iBinder;
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
            }
        }
    }
    

    绑定本地服务调用方法的步骤

    1. 在服务的内部创建一个内部类 提供一个方法,可以间接调用服务的方法
    2. 实现服务的onbind方法,返回的就是这个内部类
    3. 在activity 绑定服务。bindService();
    4. 在服务成功绑定的回调方法onServiceConnected, 会传递过来一个 IBinder对象
    5. 强制类型转化为自定义的接口类型,调用接口里面的方法。
    展开全文
  • Service两种启动方式区别

    千次阅读 2017-09-01 10:37:47
    一、Service第一种启动方式startService 生命周期:oncreate——>onstartCommand——>onDestroy;多次通过该方法启动Service,oncreate函数只会被调用一次,onStartCommand函数会被多次调用,但只需要调用一次stop...

    一、Service第一种启动方式startService

    生命周期:oncreate——>onstartCommand——>onDestroy;多次通过该方法启动Service,oncreate函数只会被调用一次,onStartCommand函数会被多次调用,但只需要调用一次stopService就可以销毁该Service;

    特点说明:通过该启动方式启动Service,一旦Service启动成功那么该Service就会和他所创建的Activity脱离关系,也就是说Service的不会随着Activity的销毁而销毁,并且在应用的任何Activiy中都可以对该Service进行操作。通过以下demo进行说明

    (1)创建一个Service类,并在生命周期方法中输出日志:

    public class MyService extends Service {
    
    
        public MyService() {
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i("MyService", "onCreate: ");
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            Log.i("MyService", "onStartCommand: ");
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.i("MyService", "onDestroy: ");
        }
    } 
    
    (2)在 SecondActivity中通过StartService的方式启动,输出结果为:


    (3)退出SecondActivity,在MainActivity中再次启动Service,输出结果为:

    09-01 10:57:47.729 28261-28261/com.example.mvp.communication I/MyService: onStartCommand:
    (4)重新进入到SecondActivity结束Service,输出结果为:


    对比上面结果可以很容易得出:Service在被一个Activity启动之后,会脱离它所启动的Activity而存在。


    二、Service第二种启动方式bindService

    生命周期:oncreate——>onBind——>unBind——>OnDestroy;多次bindService,oncreate和onBind方法都只会调用一次,而且只需要一次调用unBindService用于取消bind;

    特点说明:它与startService正好相反,一个Activity通过bind的方式启动Service,那么该Service是依赖于该Activity存在的,也就是Activity的销毁也会导致bind所启动的Service的销毁(会经历unbind——>onDestroy的生命周期);相关demo如下:
    (1)创建Service,并在Service中定义一个内部类同时继承Binder,并定义方法test(),该方法可在调用bindService的Activity中进行调用:

    public class MyService extends Service {
    
    
        public MyService() {
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i("MyService", "onCreate: ");
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            Log.i("MyService", "onStartCommand: ");
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.i("MyService", "onDestroy: ");
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            Log.i("MyService", "onBind: ");
            return new MyBinder();
        }
    
        @Override
        public boolean onUnbind(Intent intent) {
            Log.i("MyService", "onUnbind: ");
            return super.onUnbind(intent);
        }
    
        class MyBinder extends Binder {
            public void test() {
                Log.i("MyService", "test: ");
            }
        }

    (2)在SecondActivity中通过bind的方式启动Service:

    public class SecondActivity extends AppCompatActivity {
    
        private ServiceConnection connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder binder) {
                ((MyService.MyBinder) binder).test();
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) {
    
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);
        }
    
        public void click(View view) {
    
            Intent intent = new Intent(this, MyService.class);
    
            switch (view.getId()) {
                case R.id.bind:
                    bindService(intent, connection, BIND_AUTO_CREATE);
                    break;
                case R.id.unbind:
                    unbindService(connection);
                    break;
            }
        }
    }


    三、既通过startService启动也通过bindService的方式进行启动

    同时通过这两种方式进行启动,oncreate方法只会调用一次,在需要销毁Service的时候,需要同时调用stopService和unBindService(没有先后顺序)。



    展开全文
  • Android中Service两种启动方式区别

    千次阅读 2019-03-27 10:59:31
    Service是Android四大组件之一,也是可执行的程序,有自己的生命周期。创建、配置Service和创建、配置Activity的过程相似。和Activity一样,都是从Context...1、Service第一种启动方式 start方式: 使用步骤: 1....

    参考:https://www.jianshu.com/p/2fb6eb14fdec

    Service是Android四大组件之一,也是可执行的程序,有自己的生命周期。创建、配置Service和创建、配置Activity的过程相似。和Activity一样,都是从Context派生出来的。 ---《疯狂android讲义(第二版)》
    

    1、Service第一种启动方式
    start方式:
    使用步骤:

    1.定义一个类继承Service
    2.在Manifest.xml文件中配置该Service
    3.使用Context的startService(Intent)方法启动该Service
    4.不再使用时,调用stopService(Intent)方法停止该服务
    

    此种方式Service的生命周期如下:

    onCreate()--->onStartCommand()(onStart()方法已过时)  ---> onDestory()
    

    说明:如果服务已经开启,不会重复的执行onCreate(), 而是会调用onStart()和onStartCommand()。服务停止的时候调用onDestory()。服务只会被停止一次。
    特点:一旦服务开启跟调用者(开启者)就没有任何关系了。开启者退出了,开启者挂了,服务还在后台长期的运行。开启者不能调用服务里面的方法。
    2、Service第二种启动方式
    bind方式:
    使用步骤:

    1.定义一个类继承Service
    2.在Manifest.xml文件中配置该Service
    3.使用Context的bindService(Intent, ServiceConnection, int)方法启动该Service
    4.不再使用时,调用unbindService(ServiceConnection)方法停止该服务
    

    此种方式Service的生命周期如下:

    onCreate() --->onBind()--->onunbind()--->onDestory()
    

    注意:绑定服务不会调用onstart()或者onstartcommand()方法
    特点:bind的方式开启服务,绑定服务,调用者挂了,服务也会跟着挂掉。绑定者可以调用服务里面的方法。

    ================================================================================================
    扩展:
    绑定者如何调用服务里的方法呢?
    首先定义一个Service的子类。

    public class MyService extends Service {
    
        public MyService() {
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            //返回MyBind对象
            return new MyBinder();
        }
    
        private void methodInMyService() {
            Toast.makeText(getApplicationContext(), "服务里的方法执行了。。。",
                    Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 该类用于在onBind方法执行后返回的对象,
         * 该对象对外提供了该服务里的方法
         */
        private class MyBinder extends Binder implements IMyBinder {
    
            @Override
            public void invokeMethodInMyService() {
                methodInMyService();
            }
        }
    }
    

    自定义的MyBinder接口用于保护服务中不想让外界访问的方法。

    public interface IMyBinder {
    
         void invokeMethodInMyService();
    
    }
    

    接着在Manifest.xml文件中配置该Service

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

    在Activity中绑定并调用服务里的方法
    简单布局:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="start"
            android:text="开启服务"
            android:textSize="30sp" />
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="invoke"
            android:text="调用服务的方法"
            android:textSize="30sp" />
    </LinearLayout>
    

    绑定服务的Activity:

    public class MainActivity extends Activity {
    
        private MyConn conn;
        private Intent intent;
        private IMyBinder myBinder;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        //开启服务按钮的点击事件
        public void start(View view) {
            intent = new Intent(this, MyService.class);
            conn = new MyConn();
            //绑定服务,
            // 第一个参数是intent对象,表面开启的服务。
            // 第二个参数是绑定服务的监听器
            // 第三个参数一般为BIND_AUTO_CREATE常量,表示自动创建bind
            bindService(intent, conn, BIND_AUTO_CREATE);
        }
    
        //调用服务方法按钮的点击事件
        public void invoke(View view) {
            myBinder.invokeMethodInMyService();
        }
    
        private class MyConn implements ServiceConnection {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                //iBinder为服务里面onBind()方法返回的对象,所以可以强转为IMyBinder类型
                myBinder = (IMyBinder) iBinder;
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
            }
        }
    }
    

    绑定本地服务调用方法的步骤:

    • 在服务的内部创建一个内部类 提供一个方法,可以间接调用服务的方法
    • 实现服务的onbind方法,返回的就是这个内部类
    • 在activity 绑定服务。bindService();
    • 在服务成功绑定的回调方法onServiceConnected, 会传递过来一个 IBinder对象
    • 强制类型转化为自定义的接口类型,调用接口里面的方法。
    展开全文
  • Android Service 两种启动方式区别

    千次阅读 2014-05-19 10:05:32
    最近在debug android service destory的bug,网上找了service相关的知识,startservice和bindservice都可以启动service,知道这两种方式区别还是很有作用的。 Android Service 生命周期可以促使移动设备的创新...
  • Service两种启动方式的生命周期

    千次阅读 2017-02-24 09:19:26
    Service两种启动方式的生命周期
  • Service 两种启动方式

    千次阅读 2014-08-24 14:18:26
    Service的生命周期Service的生命... 我们有两种方式启动一个Service,他们对Service生命周期的影响是不一样的。    1通过startService  Service会经历onCreate->onStart  stopService的时候直接onDestroy  
  • 两种启动方式启动service,要求:观察并打印生命周期方法、思考service的使用场景以及在什么情况下service会被回收 文章目录第一种启动方式——startService启动、停止服务运行结果结论第二种启动方式——...
  • Service两种启动方式

    千次阅读 2019-03-18 15:13:53
    第一种方式:通过StartService启动Service 通过startService启动后,service会一直无限期运行下去,只有外部调用了stopService()或stopSelf()方法时,该Service才会停止运行并销毁。 要创建一个这样的Service,你...
  • Android Service两种启动方式

    千次阅读 2016-09-20 16:32:17
    1.Context.startService()方式启动  ①Context.startService()方式的生命周期: 启动时,startService –> onCreate() –> onStart()(可多次调用) ,Service running,停止时,stopService –> onDestroy() note...
  • andrid service 两种启动方式:第一种startservice,第二种bindservice,大家对这两种启动方式区别了解吗,下面跟着小编一起学习吧
  • https://blog.csdn.net/imxiangzi/article/details/76039978 启动方式 https://blog.csdn.net/bfboys/article/details/52583678 回调机制  
  • Android Service两种启动方式以及生命周期
  • Android Service两种启动方式详解

    千次阅读 2019-09-01 15:16:30
    Service分为本地服务(LocalService)和远程服务(RemoteService): 1、本地服务依附在主进程上而不是独立的进程,这样在一定程度上节约了资源,另外Local服务因为是在同一进程因此不需要IPC, 也不需要AIDL。相应...
  • Activity 启动Service两种方式区别

    千次阅读 2018-10-31 23:22:42
    Activity 启动Service两种方式: startService bindService   startService(Intent): 1.定义一个类继承Service 2.在Manifest.xml文件中配置该Service 3.使用Context的startService(Intent)方法启动该Service ...
  • Android Service两种启动方式详解(总结版)

    万次阅读 多人点赞 2017-07-25 06:10:42
    第一种方式:通过StartService启动Service 通过startService启动后,service会一直无限期运行下去,只有外部调用了stopService()或stopSelf()方法时,该Service才会停止运行并销毁。 要创建一个这样的Service,你...
  • Service两种启动方式区别

    千次阅读 2018-03-28 20:58:43
    第一种启动方式:startService(Intent)启动服务 生命周期方法流程:onCreate --- &gt; onStartCommand 关闭服务:stopService(Intent)关闭服务 生命周期方法流程 :onDestory第二种启动方式:bindService...
  • Android Service两种启动方式 1. Context.startService() Context.startService()启动方式的生命周期: 启动时:startService -> onCreate() -> onStart() 停止时:stopService -> onDestroy() 如果...
  • 继上一篇文章,Android – Service的使用,我们来继续看看Service两种启动方式第一种startService。 运行代码,得知以下几点结论: 我们了解它的启动周期为onCreate->onStartCommand,如图 当退出应用后,后台的...
  • 1.Android Service的基本用法(startService启动方式生命周期) 2.Android Service与Activity之间的通信(bindService启动方式区别如下: 一.生命周期上的区别 startService启动服务:Service会经历onCreate()---...
  • onStart()后调用bindService该service则调用onBind(),调用onBind以后调stopService将无法释放该...启动方式 1. 使用startService启动服务的生命周期方法: 使用这种方法启动一个Service,在Service启动后该Ser
  • 作为Android四大组价之一的Service,可以在很多场合中进行应用。比如当在播放音频的时候用户...开启Service主要有两种方式。 (1)startService();此种开启方式Service会经历onCreate()--onStart()。若Service还没运

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 386,846
精华内容 154,738
关键字:

service两种启动方式的区别