6.12 进一步优化看门狗 内容观察者观察数据库变化

思想: 判断当前打开的应用的包名是否在已加锁的数库中这样的做法比较耗时,   应该在内存中判断当前应用的包名是否存在已加锁包名的集合中

1. 在dao层中, 加载已加锁的应用的包名到内存中(集合中)

2.  在看门狗功能的服务中, 调用dao层加载方法, 初始化集合   (做到将数据加载到内训中
3. 在看门狗服务创建的时候, 注册内容观察者,  观察已加锁数据库delete 和  add的方法(在dao层的delete和add方法中标识被观察的数据)
4.  在内容观察者方法中, 加载已加锁数据库中的所有包名到集合中


-------------------------------------------------------------------------------------------------------------

 

在dao层中:

public
class AppLockDao {
      
      
private AppLockHelper  helper;
      
private Context  context;
      
   
public  AppLockDao(Context context){
      
helper=new AppLockHelper(context);
      
this.context=context;
    } 
   
   
   
/**
     * 增加
     */
   
public  void add(String packagename){
      SQLiteDatabase db =
helper.getWritableDatabase();
      ContentValues values=
new ContentValues();
      values.put(
"packagename", packagename);
        db.insert(
"applock", null, values);
        db.close();
       
       
//大喊一声数据发生变化了          uri: 要操作的数据
      
context.getContentResolver().notifyChange(Uri. parse("content://abc.efg"), null) ;
      
       
    }
   
   
/**
     * 删除
     */
   
public void delete(String packagename){
      SQLiteDatabase db =
helper.getWritableDatabase();
        db.execSQL(
"DELETE FROM applock WHERE packagename=?" , new Object[] {packagename});
      db.close();
      
       
//大喊一声数据发生变化了          uri: 要操作的数据
       
context.getContentResolver().notifyChange(Uri. parse("content://abc.efg"), null) ;
      
    }
   
   
   
/**
     * 查询数据库中是否存在该记录
     */
   
public boolean find(String packagename){
      
      
boolean flag=false;
      SQLiteDatabase db =
helper.getWritableDatabase();
      Cursor cursor = db.query(
"applock", null, "packagename=?", new String[]{packagename}, null, null , null);
      
      
if(cursor.moveToNext()){
            flag=
true;
      }
      cursor.close();
      db.close();
      
      
return flag;
    }
   
   
   
/**
     * 加载数据库所有的包名到内存中
     *
@return
     */
   
public List<String> findAll(){
      List<String>  packageNames=
new ArrayList<String>();
      SQLiteDatabase db =
helper.getReadableDatabase();
      Cursor cursor = db.rawQuery(
"select packagename from applock", null);
      
      
while(cursor.moveToNext()){
            String  packageName=cursor.getString(0);
            packageNames.add(packageName);
      }
      
      cursor.close();
      db.close();
      
return packageNames;
    }
   
   
 

}



---------------------------------------------------------------------------
在看门狗服务中:

public
class WatchDogService extends Service {

      
protected static final String TAG = "WatchDogService";
      
private ActivityManager  am;
      
private boolean flags;
      
private AppLockDao dao;
      
private pauseProtectBroad ppbreceiver;
      
private ScreenLockReceiver  lockReceiver;
      
private List<String> tempStopProtectPacknames;
      
private ScreenUnlockReceiver unlockReceiver;
      
private List<String>  allAppPackageList;
      
private MyObserver observer;
      
      
@Override
      
public IBinder onBind(Intent intent) {
            
            
return new MyBind();
      }
      
      
      
/**
       * 3. 创建代理人类继承服务中的Binder ,实现  watchdogInference接口  ; 在代理人 类中实现接口中未实现的方法
       *
@author Administrator
       *
       */
      
public class MyBind extends Binder  implements WatchDogInference{

            
@Override
            
public void getMethod(String pakagename) {
                  
                  temStopProtect(pakagename);  
//调用服务中的方法
            }

            
            
      }
      
      
      
      
      
/**
       * 1.服务内部的方法,把临时停止保护的应用程序的包名加入到集合里面
       *
@param pakage_name
       */
 
public void  temStopProtect(String  pakage_name){
       
       
tempStopProtectPacknames.add(pakage_name);
  }
      
      
      
      
      
/**
       * 注册自定义广播事件, 拿到watchdogActivity返回过来的包名,并告诉看门狗该应用暂时不用保护了
       */
      
public class  pauseProtectBroad  extends BroadcastReceiver{

            
@Override
            
public void onReceive(Context context, Intent intent) {
            
                  String pkgname = intent.getStringExtra(
"pkgname");   //得到暂停保护的包名
                  
tempStopProtectPacknames.add(pkgname);  //将包名装进暂停保护的集合中
                  
                  
            }
            
      }
      
      
/**
       * 注册当屏幕锁屏时的广播事件: 从暂时不受密码保护的集合中去掉该包名
       *
@author Administrator
       *
       */
      
private class ScreenLockReceiver extends BroadcastReceiver{
            
@Override
            
public void onReceive(Context context, Intent intent) {
                  
//屏幕锁屏
                  
tempStopProtectPacknames.clear();
                  
flags = false;
            }
      }
      
      
      
/**
       * 屏幕解锁时开启看门狗
       *
@author Administrator
       *
       */
      
private class ScreenUnlockReceiver extends BroadcastReceiver {
            
@Override
            
public void onReceive(Context context, Intent intent) {
                  
if (! flags) {
                        
// 屏幕解锁
                        startWatchDogThread();
                  }
            }
      }
      
      
      
      
/**
       * 服务开启时
       */
      
@Override
      
public void onCreate() {
            Log.
i(TAG, "开启服务" );
            
tempStopProtectPacknames= new ArrayList<String>();
            
allAppPackageList= new ArrayList<String>();
            
            
//当服务开启时开启初始化pass集合的广播
            
ppbreceiver = new pauseProtectBroad();
            IntentFilter filter=
new IntentFilter();
            filter.addAction(
"this.activity.not.protected");
         registerReceiver(
ppbreceiver, filter);
        
        
//当服务开启时开启清空pass集合的广播       锁屏广播
        
lockReceiver = new ScreenLockReceiver();
            IntentFilter lockFilter =
new IntentFilter();
            lockFilter.addAction(Intent.
ACTION_SCREEN_OFF);
            registerReceiver(
lockReceiver, lockFilter);
            
            
            
//解锁广播
            
unlockReceiver = new ScreenUnlockReceiver();
            IntentFilter unlockFilter =
new IntentFilter();
            unlockFilter.addAction(Intent.
ACTION_SCREEN_ON);
            registerReceiver(
unlockReceiver, unlockFilter);
            
            
            
dao= new AppLockDao(getApplicationContext()); 
            
allAppPackageList= dao.findAll();  //将数据库中的已加锁的应用的包名加载到集合中
            
//1.创建activity管理员
            
am=(ActivityManager) getSystemService( ACTIVITY_SERVICE);
            
            
//开启看门狗
            startWatchDogThread();
            
            
observer= new MyObserver( new Handler());
            

//注册广播接收者观察已标记了的数据库
            getContentResolver().registerContentObserver(Uri.
parse("content://abc.efg"), true, observer);
            
            
      
            
super.onCreate();
      }
      
      
      
      
      
/**
       * 自定义内容观察者
       */
      
private class MyObserver extends  ContentObserver{

            
public MyObserver(Handler handler) {
                  
super(handler);
            }

            
@Override
            
public void onChange( boolean selfChange) {
                  Log.
i("MyObserver" ,"发现内容变化了...." );
                  
allAppPackageList = dao.findAll();      //加载数据库所有应用的包名到集合中
                  
super.onChange(selfChange);
            }
            
      }

      
      
  
/**
    * 看门狗功能
    */
      
private void startWatchDogThread() {
            
//2.看门狗在服务开启时不停的监视着后台正在运行的程序
            
new Thread(){
                  
public void run() {
                        
flags= true;
                        
                        
while( flags){     //获取正在运行的任务栈     3:可以任意定义,表示近期开启的1个任务栈
                        List<RunningTaskInfo> runningTasks =
am.getRunningTasks(1);
                        
                        
//最上层的任务栈:   刚打开的应用程序的任务栈
                        RunningTaskInfo runningTaskInfo = runningTasks.get(0);
                        
                        
//得到刚刚开启的应用程序的activity的名称
                        String packageName = runningTaskInfo.
topActivity.getPackageName();
                        
                        
//判断得到的包名的应用是否在已加锁包名的集合中
                        
if( allAppPackageList.contains(packageName)){
                              
                              
if(! tempStopProtectPacknames.contains(packageName)){   //如果暂停保护集合中存在该包名
                                    
                                    
            Log.i(TAG, "弹出提示输入密码的activity" );
            Intent intent=new Intent(getApplicationContext(),WatchDogActivity.class );
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); //开启新任务栈
                                    
            intent.putExtra("packageName", packageName);
            startActivity(intent);
                                    
           }
                              
                              
             try {
                  Thread.sleep(50);
                 }catch (InterruptedException e) {
                                    
// TODO Auto-generated catch block
                                    e.printStackTrace();
                              }
                              
                        }
                        
                        
                        
                        }
                  };
                  
      }.start();
      }
      
      
      
/**
       * 服务销毁时
       */
      
public void onDestroy() {
            Log.
i(TAG, "关闭服务..." );
            
flags= false;  //服务关闭时关闭关门狗
            
         
//服务关闭时终止自定义广播
         
ppbreceiver.abortBroadcast();
            
         
lockReceiver.abortBroadcast();
         
         
unlockReceiver.abortBroadcast();
         
         
//取消内容观察者
          getContentResolver().unregisterContentObserver(
observer);
         
         
      };
      

}