精华内容
下载资源
问答
  • Android进程守护service保活

    千次阅读 2016-12-19 23:44:17
    android应用进程保活可以从以下来年个方面考虑 1、尽量保证应用进程不被杀死。 2、进程被杀死后能够复活。 要保证进程不被杀死是不可能的,系统在资源紧缺的情况下回根据进程优先等级杀掉有限等级比较低的进程,...
    
    


    android应用进程保活可以从以下来年个方面考虑
    1、尽量保证应用进程不被杀死。
    2、进程被杀死后能够复活。
    要保证进程不被杀死是不可能的,系统在资源紧缺的情况下回根据进程优先等级杀掉有限等级比较低的进程,所以为了使自己的进程不易于被系统杀死,只能提高进程的优先级,这个进程重要性的层次结构有五个等级,按高到低分为
    1)前台进程 Foreground process
    2)可见进程 Visible process
    3)服务进程 Service process
    4)后台进程 Background process
    5)空进程 Empty process
    Android的service置为前台startForeground,这样就提高了service的优先级。
    系统总会在某个时刻因为某些原因把你杀掉,被杀掉不可怕,可怕的是被杀掉后就再也活不过来了,so我们得制定各种策略,好让进程能在被杀后可以自启。进程被杀死后重启复活我们通过双进程守护可以是可以做到的,通过双进程守护可以在大部分情况下做到进程保活,手动清理和360等第三方软件的清理仍可以保活,对于要求比较高的场合,双进程守护是不够的,还要进行更深入的研究,系统清理进程不在本文的考虑范围之内,有兴趣的朋友可以自己去深入研究。
    双进程守护的实现:
    在应用中开启两个Service分别为LocalService和RemoteService,通过aidl相互绑定,只要其中一个呗杀死则通过另一个重启对方,这就保证了Service保活,关键的一点事LocalService和RemoteService必须要在两个不同的而进程中,我们可以通过在AndroidManifest.xml配置文件中定义
      <service android:name=".LocalService" />
      <service android:name=".RemoteService" android:process=":remote"/>
    android:process=":remote"可以保证RemoteService运行在另外一个进程中。
    下面贴出双进程守护保活的demo代码,供参考
    在包路径下定义aidl文件夹aidl
    在文件夹下定义Guard.aidl文件

    package com.guardservice.aidl;
    interface GuardAidl{
        void doSomething();
    }

    本地服务LocalService.java

    
    
    package com.guardservice;
    
    import com.guardservice.aidl.GuardAidl;
    import android.app.Notification;
    import android.app.PendingIntent;
    import android.app.Service;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.util.Log;
    
    public class LocalService extends Service {
    
    	private MyBilder mBilder;
    
    	@Override
    	public IBinder onBind(Intent intent) {
    		if (mBilder == null)
    			mBilder = new MyBilder();
    
    		return mBilder;
    
    	}
    
    	@Override
    	public void onStart(Intent intent, int startId) {
    		super.onStart(intent, startId);
    
    	}
    
    	@Override
    	public int onStartCommand(Intent intent, int flags, int startId) {
    		this.bindService(new Intent(LocalService.this, RemoteService.class),
    				connection, Context.BIND_ABOVE_CLIENT);
    
    		Notification notification = new Notification(R.drawable.ic_launcher,
    				"安全服务启动中", System.currentTimeMillis());
    		PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent,
    				0);
    		notification.setLatestEventInfo(this, "安全服务", "安全服务...", pendingIntent);
    		startForeground(startId, notification);
    		
    		return START_STICKY;
    	}
    
    	private class MyBilder extends GuardAidl.Stub {
    
    		@Override
    		public void doSomething() throws RemoteException {
    			Log.i("TAG", "绑定成功!");
    			Intent localService = new Intent(LocalService.this,
    					RemoteService.class);
    			LocalService.this.startService(localService);
    			LocalService.this
    					.bindService(new Intent(LocalService.this,
    							RemoteService.class), connection,
    							Context.BIND_ABOVE_CLIENT);
    		}
    
    	}
    
    	private ServiceConnection connection = new ServiceConnection() {
    
    		@Override
    		public void onServiceDisconnected(ComponentName name) {
    			Log.i("TAG", "RemoteService被杀死了");
    			Intent localService = new Intent(LocalService.this,
    					RemoteService.class);
    			LocalService.this.startService(localService);
    			LocalService.this
    					.bindService(new Intent(LocalService.this,
    							RemoteService.class), connection,
    							Context.BIND_ABOVE_CLIENT);
    		}
    
    		@Override
    		public void onServiceConnected(ComponentName name, IBinder service) {
    			Log.i("TAG", "RemoteService链接成功!");
    			try {
    				if (mBilder != null)
    					mBilder.doSomething();
    			} catch (RemoteException e) {
    				e.printStackTrace();
    			}
    		}
    	};
    
    }
    

    
    

    远程服务RemoteService.java

    package com.guardservice;
    
    import com.guardservice.aidl.GuardAidl;
    import android.app.Notification;
    import android.app.PendingIntent;
    import android.app.Service;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.util.Log;
    
    public class RemoteService extends Service {
    
    	private MyBilder mBilder;
    	//private final static int GRAY_SERVICE_ID = 1002;
    
    	@Override
    	public IBinder onBind(Intent intent) {
    		if (mBilder == null)
    			mBilder = new MyBilder();
    		return mBilder;
    	}
    
    	@Override
    	public void onStart(Intent intent, int startId) {
    		super.onStart(intent, startId);
    
    	}
    
    	@Override
    	public int onStartCommand(Intent intent, int flags, int startId) {
    		// 在RemoteService运行后,我们对LocalService进行绑定。 把优先级提升为前台优先级
    		this.bindService(new Intent(RemoteService.this, LocalService.class),
    				connection, Context.BIND_ABOVE_CLIENT);
    
    		Notification notification = new Notification(R.drawable.ic_launcher,
    				"安全服务启动中", System.currentTimeMillis());
    		PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent,
    				0);
    		notification.setLatestEventInfo(this, "安全服务", "安全服务...", pendingIntent);
    		startForeground(startId, notification);
    		return START_STICKY;
    	}
    
    	private class MyBilder extends GuardAidl.Stub {
    
    		@Override
    		public void doSomething() throws RemoteException {
    			Log.i("TAG", "绑定成功!");
    		}
    
    	}
    
    	private ServiceConnection connection = new ServiceConnection() {
    
    		/**
    		 * 在终止后调用,我们在杀死服务的时候就会引起意外终止,就会调用onServiceDisconnected
    		 * 则我们就得里面启动被杀死的服务,然后进行绑定
    		 */
    		@Override
    		public void onServiceDisconnected(ComponentName name) {
    			Log.i("TAG", "LocalService被杀死了");
    			Intent remoteService = new Intent(RemoteService.this,
    					LocalService.class);
    			RemoteService.this.startService(remoteService);
    			RemoteService.this.bindService(new Intent(RemoteService.this,
    					LocalService.class), connection, Context.BIND_ABOVE_CLIENT);
    		}
    
    		@Override
    		public void onServiceConnected(ComponentName name, IBinder service) {
    			Log.i("TAG", "LocalService链接成功!");
    			try {
    				if (mBilder != null)
    					mBilder.doSomething();
    			} catch (RemoteException e) {
    				e.printStackTrace();
    			}
    		}
    	};
    
    }
    

    完成


    展开全文
  • Android Service保活方法总结(不被杀死)进程守护

    万次阅读 多人点赞 2018-01-08 21:04:50
    保活Service我们需要做什么: 1.在应用被关闭后保活(最难) 2.在内用占用过大,系统自动释放内存时保活(优先杀死占用较高的Service) 3.重启手机后自动开启Service 4.手机息屏后不被释放内存 5.手动清理内存...

     

    写在前头

    保活Service我们需要做什么:

    1.在应用被关闭后保活(最难)

    2.在内用占用过大,系统自动释放内存时保活(优先杀死占用较高的Service)

    3.重启手机后自动开启Service

    4.手机息屏后不被释放内存

    5.手动清理内存时保活

     

    首先介绍一下Service的等级:

    一、前台进程
    二、可见进程
    三、服务进程
    四、后台进程
    五、空进程  ---关闭应用后,没有清理缓存

    所以为了提高优先级我们可以使用startForeground()方法将Service设置为前台进程。

     

    一、在AndroidManifest中添加Service

    <service android:name=".modle.StepService"
                android:process="istep.service"  //放入新进程
                >
                <intent-filter android:priority="1000">
                    <!-- 系统启动完成后会调用-->
                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
                    <action android:name="android.intent.action.DATE_CHANGED"/>
                    <action android:name="android.intent.action.MEDIA_MOUNTED" />
                    <action android:name="android.intent.action.USER_PRESENT" />
                    <action android:name="android.intent.action.ACTION_TIME_TICK" />
                    <action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
                    <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
                </intent-filter>
    </service>
    
    
    <service android:name=".modle.GuardService"
                android:process=":GuardService">
                <intent-filter >
                    <!-- 系统启动完成后会调用-->
                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
                    <action android:name="android.intent.action.DATE_CHANGED"/>
                    <action android:name="android.intent.action.MEDIA_MOUNTED" />
                    <action android:name="android.intent.action.USER_PRESENT" />
                    <action android:name="android.intent.action.ACTION_TIME_TICK" />
                    <action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
                    <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
                </intent-filter>
            </service>
    

     

    二、双进程保护

    1.创建aidl实现跨进程通信(新建一个aidl)

     

    interface ProcessConnection {
        /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
        //删除不必要方法
     }
    

     

    2.创建主服务

    /**
     * 主进程 双进程通讯
     * Created by db on 2018/1/11.
     */
    
    public class StepService extends Service{
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return new ProcessConnection.Stub() {};
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(1,new Notification());
            //绑定建立链接
            bindService(new Intent(this,GuardService.class),
                    mServiceConnection, Context.BIND_IMPORTANT);
            return START_STICKY;
        }
    
        private ServiceConnection mServiceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                //链接上
                Log.d("test","StepService:建立链接");
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                //断开链接
                startService(new Intent(StepService.this,GuardService.class));
                //重新绑定
                bindService(new Intent(StepService.this,GuardService.class),
                        mServiceConnection, Context.BIND_IMPORTANT);
            }
        };
    
    }
    

     

    3.创建守护服务

     /**
     * 守护进程 双进程通讯
     * Created by db on 2018/1/11.
     */
    
    public class GuardService extends Service{
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return new ProcessConnection.Stub() {};
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(1,new Notification());
            //绑定建立链接
            bindService(new Intent(this,StepService.class),
                    mServiceConnection, Context.BIND_IMPORTANT);
            return START_STICKY;
        }
    
        private ServiceConnection mServiceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                //链接上
                Log.d("test","GuardService:建立链接");
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                //断开链接
                startService(new Intent(GuardService.this,StepService.class));
                //重新绑定
                bindService(new Intent(GuardService.this,StepService.class),
                        mServiceConnection, Context.BIND_IMPORTANT);
            }
        };
    
    }
    
    

     

    返回参数含义:

     

    • START_STICKY:在Service被关闭后,重新开启Service
    • START_NOT_STICKY:服务被异常杀掉后,系统将会被设置为started状态,系统不会重启该服务,直到startService(Intent intent)方法再次被调用。
    • START_REDELIVER_INTENT:重传Intent,使用这个返回值时,如果在执行完onStartCommand后,服务被异常kill掉,系统会自动重启该服务,并将Intent的值传入。
    • START_STICKY_COMPATIBILITY:START_STICKY的兼容版本,但不保证服务被kill后一定能重启。

     

    三、使用JobService来实现应用退出后重启Service

     

    1、在AndroidManifest中添加Service和权限

    <!--JobService权限-->
        <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <receiver android:name=".modle.BootCompleteReceiver">
                <intent-filter>
                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
                </intent-filter>
    </receiver>

    2、JobService代码

    /**
     * 用于判断Service是否被杀死
     * Created by db on 2018/1/11.
     */
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)//5.0以后可用
    public class JobWakeUpService extends JobService{
        private int JobWakeUpId = 1;
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            //开启轮寻
            JobInfo.Builder mJobBulider = new JobInfo.Builder(
                    JobWakeUpId,new ComponentName(this,JobWakeUpService.class));
            //设置轮寻时间
            mJobBulider.setPeriodic(2000);
            JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
            mJobScheduler.schedule(mJobBulider.build());
            return START_STICKY;
        }
    
        @Override
        public boolean onStartJob(JobParameters jobParameters) {
            //开启定时任务 定时轮寻 判断应用Service是否被杀死
            //如果被杀死则重启Service
            boolean messageServiceAlive = serviceAlive(StepService.class.getName());
            if(!messageServiceAlive){
                startService(new Intent(this,StepService.class));
            }
    
            return false;
        }
    
        @Override
        public boolean onStopJob(JobParameters jobParameters) {
    
            return false;
        }
    
        /**
         * 判断某个服务是否正在运行的方法
         * @param serviceName
         *            是包名+服务的类名(例如:net.loonggg.testbackstage.TestService)
         * @return true代表正在运行,false代表服务没有正在运行
         */
        private boolean serviceAlive(String serviceName) {
            boolean isWork = false;
            ActivityManager myAM = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
            List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(100);
            if (myList.size() <= 0) {
                return false;
            }
            for (int i = 0; i < myList.size(); i++) {
                String mName = myList.get(i).service.getClassName().toString();
                if (mName.equals(serviceName)) {
                    isWork = true;
                    break;
                }
            }
            return isWork;
        }
    }

     

    四、保证Service在开机后自动启动

    (1)注册广播

      <receiver android:name=".modle.mReceiver">
                <intent-filter>
                    <action android:name="android.intent.action.BOOT_COMPLETED"/>
                </intent-filter>
      </receiver>

    (2)广播代码

    /**
     * 开机完成广播
     */
    
    public class mReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent){
            Intent mIntent = new Intent(context,StepService.class);
            context.startService(mIntent);
        }
    }
    

     

    五、保证息屏后不被释放资源杀死(WakeLock的使用)

    (1)添加权限

        <uses-permission android:name="android.permission.WAKE_LOCK" />

    (2)在创建Service以后调用方法

       /**
         * 同步方法   得到休眠锁
         * @param context
         * @return
         */
        synchronized private void getLock(Context context){
            if(mWakeLock==null){
                PowerManager mgr=(PowerManager)context.getSystemService(Context.POWER_SERVICE);
                mWakeLock=mgr.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,StepService.class.getName());
                mWakeLock.setReferenceCounted(true);
                Calendar c=Calendar.getInstance();
                c.setTimeInMillis((System.currentTimeMillis()));
                int hour =c.get(Calendar.HOUR_OF_DAY);
                if(hour>=23||hour<=6){
                    mWakeLock.acquire(5000);
                }else{
                    mWakeLock.acquire(300000);
                }
            }
            Log.v(TAG,"get lock");
        }
    

    (3)在onDestroy()方法中调用释放锁的方法(避免占用内存)

    synchronized private void releaseLock()
        {
            if(mWakeLock!=null){
                if(mWakeLock.isHeld()) {
                    mWakeLock.release();
                    Log.v(TAG,"release lock");
                }
    
                mWakeLock=null;
            }
        }
    PARTIAL_WAKE_LOCK 保持CPU运转,屏幕和键盘灯有可能是关闭的。
    SCREEN_DIM_WAKE_LOCK 保持CPU运转,允许保持屏幕显示但有可能是灰的,允许关闭键盘灯。
    SCREEN_BRIGHT_WAKE_LOCK 保持CPU运转,保持屏幕高亮显示,允许关闭键盘灯。
    FULL_WAKE_LOCK 保持CPU运转,保持屏幕高亮显示,键盘灯也保持亮度。
    ACQUIRE_CAUSES_WAKEUP 不会唤醒设备,强制屏幕马上高亮显示,键盘灯开启。有一个例外,如果有notification弹出的话,会唤醒设备。
    ON_AFTER_RELEASE Wake Lock被释放后,维持屏幕亮度一小段时间,减少Wake Lock循环时的闪烁情况。

     

     

    六、启动所有Service(在Activity中)

       /**
         * 开启所有Service
         */
        private void startAllServices()
        {
            startService(new Intent(this, StepService.class));
            startService(new Intent(this, GuardService.class));
            if(Build.VERSION.SDK_INT >=Build.VERSION_CODES.LOLLIPOP) {
                Log.d(TAG, "startAllServices: ");
                //版本必须大于5.0
                startService(new Intent(this, JobWakeUpService.class));
            }
        }

     

    注意:该方法不能保证在所有机型上有效,而且除非在必要时,否则不建议写这样的流氓软件。特别是谷歌在android7.0以后对管理加强,想要保活Service其实已经变得不太可能了,谷歌这样做无疑是为了减少流氓软件的数量,这样做也是可取的。
     

     

     

     

    展开全文
  • Android Service保活最佳实践

    千次阅读 2019-04-28 17:38:08
    最近的项目因为服务在后台被杀...进程守护 这个方法貌似现在不行了。 START_STICKY 一开始就有,没什么用。 使用前台进程 可以实现保活,但是通知栏会有xxx正在运行的通知,很难受。网上说的使用两个前台进程...
    最近的项目因为服务在后台被杀,导致重新进入页面时遇到若干问题,网上搜了好多方案,都不可行,基本都过时了,所以自己总结了一下,我的保活策略就是不保活。

    顺便提一下网上现有的保活方法,我试过了是没有成功的:

    • 双进程守护
    这个方法貌似现在不行了。
    • START_STICKY
    一开始就有,没什么用。
    • 使用前台进程
    可以实现保活,但是通知栏会有xxx正在运行的通知,很难受。网上说的使用两个前台进程,然后stop掉第二个前台进程的方法,现在用不了了,所以这个方案也不行了。

    我的方案

    1.不使用前台进程。
    2.START_STICKY还是要的。
    3. 在Application里监听Activity的生命收起,在activity start的时候判断服务是否还在,如果不在了,启动服务。
    4.如果确定服务被杀死的时候走了onDestroy,可以定义一个全局变量,在activity start的时候加上这个判断,判断服务是不是destroy了。我就是这么做的。

    部分代码

    //在Service里
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            ModuleManager.getInstance().isBluetoothServiceDestroyed=false;
            Log.i("Service", "UnreadMessageServices onStartCommand");
            return START_STICKY;
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            ModuleManager.getInstance().isBluetoothServiceDestroyed=true;
        }
    
    	//在Application里
    
          BaseApplication.getDefault().registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
                @Override
                public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                    registerFragmentLifeCycle(activity);
                    initAnalysisWhenCreated(activity);
                }
    
                @Override
                public void onActivityStarted(Activity activity) {
                    if (isBluetoothServiceDestroyed&&!CommonUtils.isServiceExisted(BaseApplication.getDefault(), "com.XXXX.BluetoothService")) {
                        Intent it = new Intent(BaseApplication.getDefault(), BluetoothService.class);
                        BaseApplication.getDefault().startService(it);
                        L.e(TAG,"WWWWWWWWWWWWWWWWWWWWWWWWWWWWW Activity start,重启蓝牙服务");
                    }
                }
    }
    
    
    
    	public static boolean isServiceExisted(Context context, String className) {
        ActivityManager activityManager = (ActivityManager) context
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> serviceList = activityManager
                .getRunningServices(Integer.MAX_VALUE);
    
        if (!(serviceList.size() > 0)) {
            return false;
        }
    
        for (int i = 0; i < serviceList.size(); i++) {
            ActivityManager.RunningServiceInfo serviceInfo = serviceList.get(i);
            ComponentName serviceName = serviceInfo.service;
    
            if (serviceName.getClassName().equals(className)) {
                return true;
            }
        }
        return false;
    }
    
    展开全文
  • 双Service联合保活,与腾讯系应用共享通道 有效提升消息抵达率 ----https://xg.qq.com/ctr_index/intro   SraumSmartHome com.massky.sraum       SDK - Android 以下列出的ID及Key,用于 Android ...

    高抵达率,稳定长连接

    业内领先的技术实力,稳定可靠的消息推送通道
    双Service联合保活,与腾讯系应用共享通道
    有效提升消息抵达率

    ----https://xg.qq.com/ctr_index/intro

     

    SraumSmartHome

    com.massky.sraum

     

     

     

    SDK - Android

    以下列出的ID及Key,用于 Android Push SDK的接入

    APP ID

    fcb9c23420056

    SECRET KEY

    511d1d0c7da17361d31b50ff99b3136d

    ACCESS ID

    2100321033

    ACCESS KEY

    AI51L25GL8SC

    客户端SDK

    点击下载

    一键接入指南

    点击查看

     如果您需要使用「厂商/海外推送通道」,请确认已经按照集成文档中的说明进行集成,避免造成重复发版。

    展开全文
  • 进程的保活,在很多资讯类的App和即时通讯App的用处很大,奈何谷歌的推送服务在国内是被阉割了!据说是在8.0(奥利奥)相关政府机构已经将开放这项功能提上了日程,嗯,没错8.0,预计再过三五年就可以像苹果那样...
  • 一、 进程守护保活原理、 二、 进程守护保活完整源码、 1、AIDL 接口、 2、本地前台服务 Service、 3、远程前台服务 Service、 4、清单配置、 5、启动两个服务、 5、执行效果、 三、 源码资源
  • 应用进程白色保活

    2017-08-18 12:04:13
    清单配置: <service android:name="com.service.Service1" android:enabled="true" android:process=":Service1"> <service android:name="com.serv
  • 本文分为两个部分,第一部分为双Service守护,第二部分为双进程守护 第一部分: 一、Service简介: Java.lang.Object  ↳Android.content.Context  ↳android.content.ContextWrapper  ↳android...
  • 耍流氓式的保活service

    2018-02-13 11:42:43
    oomkilladj(越小越重要),如启动Service调用startForeground()尽量提高进程的优先级; 2.当应用退到后台适当释放资源然后降低APP的内存占用量,因为在oom_adj相同的时候,会优先干掉内存消耗大的进程; 进程.....
  • 进程保活进程守护

    千次阅读 2017-05-21 11:29:41
    进程守护场景:home键,系统应用管理,直接杀死进程,进程仍然处于运行状态; 适用手机类型:50%的手机。 进程守护原理: 进程A 进程B 删除A,同时创建B 删除B,同时创建A 前提相关知识: 1、Service分类...
  • 进程保活

    2019-08-17 16:37:09
    以前常见的进程保活方案有:监听系统广播、定时器、JobScheduler、进程、提高Service优先级等。 而现在Android版本更新到9.0了,面对高版本,比较行之有效的方法是: 弹出通知栏、进程、播放无声音乐 进程:...
  • Android进程保活·设置前台Service,提升App进程优先级 Android进程 首先你要知道Android中的进程以及它的优先级,下面来说明它进程 前台进程 (Foreground process) 可见进程 (Visible process) 服务进程 ...
  • Android进程保活——进程守护

    千次阅读 2018-03-02 10:12:09
    这样的一款手机应用,就一流氓软件,后台一直有service在跑着,如果功耗很大,而且对用户来说不是很重要的app,很大可能性被用户卸载。 奈何,这几天做的app就有这个需求,一款结合物联网的app,这个app其中的一个...
  • 进程的保活

    2017-10-30 14:10:13
    黑色保活:不同的app进程,用广播相互唤醒(包括利用系统提供的广播进行唤醒)(进程守护) 白色保活:启动前台Service(startForeground) 灰色保活:利用系统的漏洞启动前台Service ...
  • 对于Android来说,保活主要有以下一些方法: - 开启前台Service(效果好,推荐) - Service中循环播放一段无声音频(效果较好,但耗电量高,谨慎使用) - 进程守护(Android 5.0前有效) - JobScheduler...
  • 对于Android来说,保活主要有以下一些方法: - 开启前台Service(效果好,推荐) - Service中循环播放一段无声音频(效果较好,但耗电量高,谨慎使用) - 进程守护(Android 5.0前有效) - JobScheduler...
  • 1:加入一中保活唤醒机制,2个service在用户清理内存的时候相互唤醒。 2:消息通知,和唤醒机制一起保持连接,用户收到信息可以打开自己的app应用
  • 这篇文章里总结了一些进程保活方法,下文以进程守护和进程提权来保活我们的服务进程。进程守护: 主要设计AB两个不同服务进程,A进程的服务轮询检查B进程的服务是否存活,没存活的话将其拉起,同样B进程服务...
  • 进程保活-进程守护的正确姿势

    千次阅读 2017-07-17 20:05:26
    做车机的开发免不了在后台开...进程守护,肯定得用到多进程,一个应用可以有多个进程的,如何实现多进程呢,service或者activity等都有一个属性android:process,只要设置起名称就可指定该组件运行在该进程中。在这里
  • 做Android 保活的背景由于之前做一个项目的时候需要让进程一直在后台活下去保持不被杀死的状态,因此也是各种百度各种苦苦寻找,本来是想着靠Service来做保活的,因为我的手机是6.0系统的,之前试过的各种依靠...
  • Android 进程保活

    2019-08-13 11:47:31
    进程保活 1,1像素 创建一个1像素的activity,透明且无动画切换,打开屏幕时把它关闭,把这些逻辑放在一个service中,并把次service放在另一个线程。这样每次mainactivity开启服务的时候,此线程会更加轻量化,不...
  • 对于Android来说,保活主要有以下一些方法:开启前台Service(效果好,推荐)Service中循环播放一段无声音频(效果较好,但耗电量高,谨慎使用)进程守护(Android 5.0前有效)JobScheduler(Android 5.0后引入,8.0后...
  • 对于Android来说,保活主要有以下一些方法:开启前台Service(效果好,推荐)Service中循环播放一段无声音频(效果较好,但耗电量高,谨慎使用)进程守护(Android 5.0前有效)JobScheduler(Android 5.0...
  • 关于进程保活的一切

    2020-06-20 22:43:06
    进程保活一、进程保活 6.0以下1)监听广播方式2)提高Service的优先级3)全局定时器4)应用中的双service拉起5)应用中的双进程拉起6)单进程守护7)双进程守护二、进程保活 6.0~8.0(一)防杀策略1)开启前台...
  • 对于Android来说,保活主要有以下一些方法:开启前台Service(效果好,推荐)Service中循环播放一段无声音频(效果较好,但耗电量高,谨慎使用)进程守护(Android 5.0前有效)JobScheduler(Android 5.0...
  • Android 8.0以上系统应用如何保活

    千次阅读 多人点赞 2019-08-22 15:45:09
    最近在做一个埋点的sdk,由于埋点是分批上传的,不是每次都上传,所以会有个进程保活的机制,这也是自研推送的实现技术之一:如何保证Android进程的存活。...进程守护(Android 5.0前有效) JobScheduler(Andro...
  • 参考资料:gitbub上的一个进程保活的库安卓进程保活解决方案Android进程保活招式大全...该库总的来说就是整合了:一像素Activity,前台Servcie,Service设置START_STICKY,播放无声音乐Servcie,进程守护Service

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

双service保活