android service 执行一段时间后停止 android service启动方式及生命周期

1、服务生命周期

1.1 介绍

Service运行在主线程中。

 

1.2 Service典型生命周期

 

Service典型生命周期

onCreate()
onStartCommand(Intent intent, int flags, int startId)
onDestroy()
onBind()

Service非典型生命周期

onLowMemory()
onTrimMemory(int level)

 

2、服务分类

2.1 服务启动方式分类：

启动服务

服务启动后，用户没法跟其进行交互，直到服务自己主动结束调用onDestory()方法。（放飞）

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

绑定服务

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

 

 

2.2 服务生命力分类：

 

后台服务

在一般情况下，Service几乎都是在后台运行，一直默默地做着辛苦的工作。但这种情况下，后台运行的Service系统优先级相对较低，当系统内存不足时，在后台运行的Service就有可能被回收。

 

前台服务

那么，如果我们希望Service可以一直保持运行状态且不会在内存不足的情况下被回收时，可以选择将需要保持运行的Service设置为前台服务。

•       前台Service的系统优先级更高、不易被回收；

•       前台Service会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。

 

 

2.3 是否运行在主线程：

自定义service  — 运行在主线程

 

IntentService  — 不是运行在主线程

正如我们以前提到的，Service运行在主线程中。所以，我们在Service中实现逻辑时要非常小心。要考虑如果这个逻辑是一个阻塞操作，或者需要很长时间才能结束，可能会引发ANR问题。在这种情况下，我们要将逻辑移到独立的线程中。这就意味着，要在onStartCommand方法中创建一个线程，然后运行它。

从Service派生的另一个IntentService类可以简化我们的开发。当不需要在同一时间去处理多个请求时，这个类比较好用。这个类创建了一个工作线程来处理不同的请求。执行的操作如下：

•     创建一个单独的线程来处理请求。

•     创建一个请求队列并偶尔传递一个Intent。

•     创建一个默认的onStartCommand实现。

•     在所有的请求执行完毕后结束Service。

 

3、举例

 

3.1 自定义service的两种启动方式

1、自定义MyService，继承自Service；

public class MyService extends Service {

    String tag = "060_MyService";

    private LocalBinder binder = new LocalBinder();

    /**
     * 创建Binder对象，返回给客户端即Activity使用，提供数据交换的接口
     */
    public class LocalBinder extends Binder {
        // 声明一个方法，getService。（提供给客户端调用）
        MyService getService() {
            // 返回当前对象LocalService,这样我们就可在客户端端调用Service的公共方法了
            return MyService.this;
        }
    }

    /**
     * 把Binder类返回给客户端
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e(tag, "MyService onBind");
        return binder;
    }

    /**
     * 重写Service生命周期
     */
    int count = 0;
    Timer timer = new Timer();
    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(tag, "MyService onCreate");

        /* 注册屏幕唤醒时的广播 */
        IntentFilter mScreenOnFilter = new IntentFilter("android.intent.action.SCREEN_ON");
        registerReceiver(mScreenOReceiver, mScreenOnFilter);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                count++;
                Log.e(tag,"count ++ : " + (count));
            }
        }, 100,1000);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(tag,"MyService onStartCommand invoke");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(tag, "MyService onDestroy ，count is ：" + count);
        unregisterReceiver(mScreenOReceiver);
    }


    private BroadcastReceiver mScreenOReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();

            if (action.equals("android.intent.action.SCREEN_ON")) {
                Log.e(tag, "—— SCREEN_ON ——");
            } else if (action.equals("android.intent.action.SCREEN_OFF")) {
                Log.e(tag, "—— SCREEN_OFF ——");
            }
        }
    };

    @Override
    public void onLowMemory(){
        super.onLowMemory();
    }

    @Override
    public void onTrimMemory(int level){
        super.onTrimMemory(level);
    }

    /**
     * 公共方法
     * @return
     */
    public int getCount(){
        return 10;
    }

}

2、在配置文件里声明

<service android:name="com.hy.base.androidbase.component.service.MyService"/>

3、start启动方式

Intent it = new Intent(MyApplication.getContext(), MyService.class);
private void startservice() {
    startService(it);
}
private void stopservice() {
    stopService(it);
}

4、bind启动方式

private void bindservice() {
    Log.e(tag, "绑定调用：bindservice");
    bindService(it, conn, Service.BIND_AUTO_CREATE);
}
private void unbindservice() {
    Log.e(tag, "解除绑定调用：unbindService");
    // 解除绑定
    if(mService!=null) {
        mService = null;
        unbindService(conn);
    }
}
private void getdata() {
    Log.e(tag, "获取数据：getdata");
    if (mService != null) {
        // 通过绑定服务传递的Binder对象，获取Service暴露出来的数据

        Log.e(tag, "从服务端获取数据：" + mService.getCount());
    } else {

        Log.e(tag, "还没绑定呢，先绑定,无法从服务端获取数据");
    }
}

 

3.2 前台service

1、自定义MyForegroundService，继承自Service；

public class MyForegroundService extends Service {

    String tag = "060_MyForegroundService";

    /**
     * 重写Service生命周期
     */
    @Override
    public IBinder onBind(Intent arg0) {
        Log.e(tag, "MyForegroundService onBind");
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e(tag, "MyForegroundService onCreate");

        //android 3.0后创建notification的方式
        Notification.Builder builder = new Notification.Builder(this.getApplicationContext());
        Intent nfIntent = new Intent(this, MainActivity.class);
        builder.setContentIntent(PendingIntent.getActivity(this, 0, nfIntent, 0))
                .setLargeIcon(BitmapFactory.decodeResource(this.getResources(), R.mipmap.ic_launcher))
                .setContentTitle("来自前台服务提示Title")
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentText("来自前台服务提示要显示的内容")
                .setWhen(System.currentTimeMillis());
        Notification notification = builder.build();
        //设置为默认的声音
        notification.defaults = Notification.DEFAULT_SOUND;

        startForeground(1, notification);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(tag,"MyForegroundService onStartCommand invoke");
        return super.onStartCommand(intent, flags, startId);

    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(tag, "MyForegroundService onDestroy");

    }


}

2、在配置文件里声明

<service android:name="com.hy.base.androidbase.component.service.MyForegroundService"/>

3、start启动方式

final Intent intent = new Intent(MyApplication.getContext(), MyForegroundService.class);
private void startforeground() {
    //0,开启前台服务,1,关闭前台服务
    intent.putExtra("cmd", 0);
    startService(intent);
}
private void stopforeground() {
    //0,开启前台服务,1,关闭前台服务
    intent.putExtra("cmd", 1);
    startService(intent);
}

 

3.3 IntentService

1、自定义MyForegroundService，继承自Service；

public class MyIntentService extends IntentService { 
/** * 是否正在运行 */ private boolean isRunning; 
/** *进度 */ private int count; /** * 广播 */ 
private LocalBroadcastManager mLocalBroadcastManager; 
public MyIntentService() { 
super("MyIntentService"); 
Logout.e("MyIntentService"); } 
@Override public void onCreate() { 
super.onCreate(); Logout.e("onCreate"); 
mLocalBroadcastManager = LocalBroadcastManager.getInstance(this); } 
 
Override 
protected void onHandleIntent(Intent intent) { 
Logout.e("onHandleIntent"); 
try { 
Thread.sleep(1000); 
isRunning = true; count = 0; 
while (isRunning) { 
count++; 
if (count >= 100) { 
isRunning = false; } 
Thread.sleep(50); 
sendThreadStatus("线程运行中...", count); 
} } 
catch (InterruptedException e) { 
e.printStackTrace(); } } 
 
/** * 发送进度消息 */ 
private void sendThreadStatus(String status, int progress) { 
Intent intent = new Intent(IntentServiceActivity.ACTION_TYPE_THREAD); 
intent.putExtra("status", status); intent.putExtra("progress", progress); 
mLocalBroadcastManager.sendBroadcast(intent); } 
@Override public void onDestroy() { 
super.onDestroy(); 
Logout.e("线程结束运行..." + count); }}

2、在配置文件里声明




3、start启动方式