Android绑定系统图标，类似各种电话本的绑定图标功能

这是一篇我个人在EOE发的帖子《绑定系统图标，类似各种电话本的绑定图标功能》，由于eoe的blog系统实在是无言以对，我就把eoe上面的帖子以及blog是都转到csdn上来，原帖地址：http://www.eoeandroid.com/thread-542422-1-1.html

先说下背景把，之前要做一个融合的Contacts+Mms+ Dialer的一个项目，这个项目最初是要往第三方方面发展，然后要做一个功能：点击系统的联系人，信息，拨号的icon然后把我们的app启动起来，然后切换到相应的tab（做了类似功能的目前市面的app有：微信电话本，有你短信，触宝号码助手，360电话本，上面几个都是我自己体验并反编译过他们的apk的，看的code太多了，就不贴截图了）

这个功能呢，其实非常流氓，我也是通过看了一篇文章（ 文章地址：http://imid.me/blog/2013/08/16/weixin-phonebook-case-study/）才知道他们是具体怎么做了，花了3天时间把基本功能做出来了，后面断断续续的优化功能也有一段时间
现在的情况是，我们的产品要进我们的rom了，进rom的话，我们就不需要这个功能了，所以把我之前研究的时候对整个流程的分析和我自己实现的demo分享出来

但是，希望大家不要利用这个去做一些不好的事情

通过上面那篇文章的分析，主要的做法就是利用WindowManager在整个屏幕窗口上添加一个透明且优先级比较高的窗口（是一个自定义View），然后监控屏幕的touch，用户touch一次就去检测一下系统目前运行的所有app，在RunningTask里看栈顶的app是不是我们要绑定的app，如果是就启动我们的app，如果不是就不用管了，而判断是不是我们要绑定的app，是通过         
RunningTaskInfo runningTaskInfo = localObject.get(0);
ComponentName topActivity = runningTaskInfo.topActivity;
String topActivityClassName = topActivity.getClassName();
通过topActivity的类名，我们在启动这个监控的时候会获取一下我们需要的绑定的app的集合，然后在这个集合中过滤
基本思路就是这样那下面就开始具体实现：（另外本帖主要分析微信电话本{以下称wxdhb}的一些逻辑流程和我自己的实现，其他的app我也反编译过，基本差不多的思路）
1、首先UI上有三个开关

开关的作用是发送自定义的广播，接收到广播之后来初始化一些数据，然后开启service，然后添加透明窗口（其实可以直接添加透明窗口，wxdhb中好像就是直接搞的），(demo里有些地方code写的有些冗余了，后期优化的时候直接在项目里做的，就没优化demo的code了，所以大家可以看着修改)//发送广播

    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        SharedPreferences sp = getActivity().getSharedPreferences(BindActions.SCREEN_BIND_ACTIONS, Context.MODE_PRIVATE);
        Intent i = new Intent(BindActions.BIND_ACTION);
        switch (buttonView.getId()) {
            case R.id.sw_call:
                sp.edit().putBoolean(BindActions.BIND_ICON_ACTION_+"Call", buttonView.isChecked()).commit();
                break;
            case R.id.sw_contacts:
                sp.edit().putBoolean(BindActions.BIND_ICON_ACTION_+"Contacts", buttonView.isChecked()).commit();
                break;
            case R.id.sw_mms:
                sp.edit().putBoolean(BindActions.BIND_ICON_ACTION_+"Mms", buttonView.isChecked()).commit();
                break;
            default:
                break;
        }
        getActivity().sendBroadcast(i);
    }
public class ScreenStateReceiver extends BroadcastReceiver {
……
    @Override
    public void onReceive(Context context, Intent intent) {
//接受到上面发送的广播，而且我们的不止是需要接收自己的广播，还需要监听系统的一些广播，比如屏幕点亮和屏幕解锁，且我们还要自启动的时候就开始监听了，所以需要接收多个action
        String intent_action = intent.getAction();
        if(BindActions.BIND_ACTION.equals(intent_action)){
            handleBindEvent(context, intent);
        } else if(Intent.ACTION_USER_PRESENT.equals(intent_action)){
            //Log.i("LM", "ACTION_USER_PRESENT");
            SystemClock.sleep(200);
            handleBindEvent(context, intent);
        } else if(Intent.ACTION_SCREEN_ON.equals(intent_action)){
            //Log.i("LM", "ACTION_SCREEN_ON");
            handleBindEvent(context, intent);
        } else if(Intent.ACTION_SCREEN_OFF.equals(intent_action)){
            //Log.i("LM", "ACTION_SCREEN_OFF");
        }else if(Intent.ACTION_BOOT_COMPLETED.equals(intent_action)){
            //Log.i("LM", "ACTION_BOOT_COMPLETED");
            handleBindEvent(context, intent);
        }

2、那么下面service中，我们注册广播，和判断是否需要添加透明窗口，然后来进行窗口的添加和移除

public class BindIconsService extends Service {
……
    @Override
    public void onCreate() {
        super.onCreate();
        receiver = new ScreenStateReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_USER_PRESENT);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_SCREEN_ON);
        registerReceiver(receiver, filter );// 屏幕点亮的广播，必须在code中注册才有效
    }
   @Override
    public void onDestroy() {
        super.onDestroy();
        if(receiver != null){
            unregisterReceiver(receiver);
        }
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        SharedPreferences sp = getSharedPreferences(BindActions.BIND_SERVICE_STATE,Context.MODE_PRIVATE);
        boolean b = sp.getBoolean(BIND_TAG, false);// 获取是否需要绑定
        if (b) {
            AlertView.removeAlertWindow(this);//不需要绑定，删除AlerView，并停止service
            stopSelf();
        } else {
            createView();
        }
        return START_STICKY;
    }
    /**
     * 添加透明窗口
     */
    private void createView() {
        SharedPreferences sp = getSharedPreferences(BindActions.SCREEN_BIND_ACTIONS, Context.MODE_PRIVATE);
        boolean _call = sp.getBoolean(BindActions.BIND_ICON_ACTION_+"Call", true);
        boolean _contacts = sp.getBoolean(BindActions.BIND_ICON_ACTION_+"Contacts", true);
        boolean _mms = sp.getBoolean(BindActions.BIND_ICON_ACTION_+"Mms", true);
        AlertView.addAlertWindow(this, _call, _contacts, _mms);//alertview就是那个自定义VIew
    }

3、关键的这个AlertView，这个view是透明的，悬浮在系统窗口之上，然后接收touch的时候调用一下我们自己的一个方法来进行一些判断的逻辑，但是注意不要把touchevent拦截掉了(要不然用户无法使用手机了，像我们开发的知道原因的话，还可以cmd下使用adb命令卸载掉，给小白用户用，估计要哭了)

public class AlertView extends View {
……
   /**
     * 停止接受信息
     */
    private void stopHandleTouch(){
        if(this.eventHandler == null){
            return;
        }
        this.eventHandler.quit();
        this.eventHandler = null;
    }
    /**
     * 删除透明窗口
     * @param context
     */
    public static void removeAlertWindow(Context context) {
        if (singleAlertView == null)
            return;
        if(singleAlertView != null){
            singleAlertView.stopHandleTouch();
        }
        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        windowManager.removeView(singleAlertView);
        singleAlertView = null;
    }
    /**
     * 添加透明窗口
     * @param paramContext
     * @param is_bind_call
     * @param is_bind_contacts
     * @param is_bind_mms
     */
    public static void addAlertWindow(Context paramContext,boolean is_bind_call,boolean is_bind_contacts,boolean is_bind_mms) {
        if(singleAlertView != null){
            removeAlertWindow(paramContext);
        }
        singleAlertView = new AlertView(paramContext, is_bind_call, is_bind_contacts, is_bind_mms);
        addAlertView(paramContext);
    }
    /**
     * 开始接受屏幕touch事件的信息
     * @param paramContext
     */
    private void startHandleTouch(Context paramContext) {
        this.eventHandler = new TouchEventHandlerThread(this, paramContext);
        this.eventHandler.start();
        this.eventHandler.checkTop();
    }

    private static int exception_count = 0;
    /**
     * 添加窗口,<font color="#ff0000">这个方法的一些参数，我自己研究了很久，也去对应api了，上面几个都可以对应出来具体参数，但**   是</font>localLayoutParams.flags <font color="#ff0000">这个参数，我真的不知道是个什么鸟意思，但是这个值很关键，换其他值view没效果（这段code我记得是从wxdhb和触宝电话本里抠出来结合了一下吧）</font>
     * @param paramContext
     */
    private static void addAlertView(Context paramContext) {
        if (singleAlertView == null)
            return;
        WindowManager localWindowManager = (WindowManager) paramContext.getSystemService(Context.WINDOW_SERVICE);
        singleAlertView.setBackgroundColor(0);
        WindowManager.LayoutParams localLayoutParams = new WindowManager.LayoutParams();
        localLayoutParams.width = 1;
        localLayoutParams.height = 1;
        localLayoutParams.gravity = 51;
        localLayoutParams.x = 0;
        localLayoutParams.y = 0;
        localLayoutParams.format = 1;
        localLayoutParams.type = 2010;
        localLayoutParams.flags = 262152;
        try {
            localWindowManager.addView(singleAlertView, localLayoutParams);
            singleAlertView.startHandleTouch(paramContext);
            return;
        } catch (Exception localException1) {
            if(DEBUG){
                logMsg("Exception->"+localException1.getMessage());
            }
            removeAlertWindow(paramContext);
            if(exception_count > 5){
                if(DEBUG){
                    logMsg("can not add alertview ,exception:-->"+localException1.getMessage());
                }
                return;
            }
            addAlertView(paramContext);
            exception_count++;
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if ((this.eventHandler != null) && (this.eventHandler.isAlive()))
            this.eventHandler.checkTop();
        logMsg("onTouchEvent---");
        return super.onTouchEvent(event);
    }

4、当然整个判断的逻辑的过程要放在线程中执行，所以在这个类中还会用到TouchEventHandlerThread，该类中也有很变态的检车栈顶的方法，做出来的效果，和其他的差不多，可能在app切换的时候做的还是有点差距，不过功能实现了，就是慢慢优化的事了

public class TouchEventHandlerThread extends HandlerThread {
……
   /**
     * 判断是否有需要绑定
     * @return
     */
    private boolean hasBind() {
        if (alertView == null) {
            return false;
        } else {
            return alertView.isIs_bind_call() || alertView.isIs_bind_contacts()
                    || alertView.isIs_bind_mms();
        }
    }
    /**
     * 添加需要过滤的类名信息
     */
    public void initFilterActions() {
        Intent i_call = new Intent();
        i_call.setAction("android.intent.action.CALL_BUTTON");
        addFilterString(i_call, bind_set_call);
        Intent i_dial = new Intent();
        i_dial.setAction("android.intent.action.DIAL");
        addFilterString(i_dial, bind_set_call);
        Intent localIntent5 = new Intent();
        localIntent5.setAction("android.intent.action.CALL");
        addFilterString(localIntent5, bind_set_call);
        // s6
        bind_set_call.add("com.yulong.android.contacts.dial.DialActivity");
        // suning
        bind_set_call.add("com.android.contacts.activities.DialtactsActivity");

        Intent i_contents = new Intent();
        i_contents.setAction("android.intent.action.VIEW");
        i_contents.setType("vnd.android.cursor.dir/contact");
        addFilterString(i_contents, bind_set_contacts);
        Intent i_person = new Intent("android.intent.action.VIEW");
        i_person.setType("vnd.android.cursor.dir/person");
        addFilterString(i_person, bind_set_contacts);
        // meizu 
        bind_set_contacts.add("com.meizu.mzsnssyncservice.ui.SnsTabActivity");
        bind_set_contacts.add("com.sec.android.app.contacts.PhoneBookTopMenuActivity");
        // xiaomi
        bind_set_contacts.add("com.android.contacts.activities.TwelveKeyDialer");
        bind_set_contacts.add("com.android.mms.ui.MmsTabActivity");
        bind_set_contacts.add("com.android.contacts.activities.PeopleActivity");
        // s6
        bind_set_contacts.add("com.yulong.android.contacts.ui.main.ContactMainActivity");
        Intent i_mms = new Intent();
        i_mms.setAction("android.intent.action.MAIN");
        i_mms.setType("vnd.android.cursor.dir/mms");
        addFilterString(i_mms, bind_set_mms);
        Intent i_mms_2 = new Intent("android.intent.action.VIEW");
        i_mms_2.setType("vnd.android-dir/mms-sms");
        addFilterString(i_mms_2, bind_set_mms);

        bind_set_mms.add("com.android.mms.ui.ConversationList");
        bind_set_mms.add("com.android.mms");
        // huawei
        bind_set_mms.add("com.huawei.message");
        // sony
        bind_set_mms.add("com.sonyericsson.conversations");
        // motorola
        bind_set_mms.add("com.motorola.blur.conversations");
        bind_set_mms.add("com.android.mms.ui.SingleRecipientConversationActivity");
        bind_set_mms.add("com.android.mms.ui.NewMessagePopupActivity");
        // s6
        bind_set_mms.add("com.yulong.android.mms.ui.MmsMainListFormActivity");
        // 360
        bind_set_call.add("com.qihoo360.contacts.contacts");
        bind_set_contacts.add("com.qihoo360.contacts.safecontacts");
        bind_set_mms.add("com.qihoo360.contacts.mms");

        bind_set_mms.add("com.google.android.talk.SigningInActivity");
        bind_set_mms.add("com.google.android.apps.babel.fragments.SmsOobActivity");
    }
    /**
     * 根据Intent去系统中查询可以启动该类intent的程序信息
     * @param paramIntent
     * @param bind_set
     */
    private void addFilterString(Intent paramIntent, HashSet<String> bind_set) {
        try {
            ContextWrapper contextWrapper = (ContextWrapper) mContext;
            PackageManager packageManager = contextWrapper.getPackageManager();
            List<ResolveInfo> queryIntentActivities = packageManager.queryIntentActivities(paramIntent,PackageManager.MATCH_DEFAULT_ONLY);
            for (ResolveInfo resolveInfo : queryIntentActivities) {
                String packageName = resolveInfo.activityInfo.packageName;
                String name = resolveInfo.activityInfo.name;
                String targetActivity = resolveInfo.activityInfo.targetActivity;
                if (!TextUtils.isEmpty(name)) {
                    bind_set.add(name);
                }
                if (!TextUtils.isEmpty(targetActivity)) {
                    bind_set.add(targetActivity);
                }
            }
        } catch (Exception e) {
            logMsg("----------"+e.getMessage());
        }
    }

    boolean isSuccess = false;
    private int temp = 10;
    /**
     * 检查栈顶
     */
    public void checkTop() {
        isSuccess = false;
        if (this.mHandler == null)
            return;
        this.mHandler.removeMessages(TouchHandler.MSG_WHAT_COMMENT);
        if(!hasBind()){
            return;
        }
        long i = 400L;
        while (true) {
            if(isSuccess){
                break;
            }
            if (i >= 600) {
                this.mHandler.sendEmptyMessageDelayed(TouchHandler.MSG_WHAT_COMMENT_FAILED, i);
                return;
            }
            this.mHandler.sendEmptyMessageDelayed(TouchHandler.MSG_WHAT_COMMENT, i);
            i += temp;
        }
    }
    /**
     * 检查栈顶的Acitivity的类型（是否需要绑定）
     * @return
     */
    private int checkTopType() {
        SystemClock.sleep(200);
        int lanch_type = LANCH_TYPE_NONE;
        List<RunningTaskInfo> localObject = mActivityManager.getRunningTasks(1);
        if (localObject != null && localObject.size() > 0) {
            RunningTaskInfo runningTaskInfo = localObject.get(0);
            ComponentName topActivity = runningTaskInfo.topActivity;
            String topActivityClassName = topActivity.getClassName();
            if(mContext == null){
                return lanch_type;
            }
            if (mContext.getPackageName().equals(topActivity.getPackageName())) {
                isSuccess = true;
            }
            logMsg("topActivityClassName->"+topActivityClassName);
            if (bind_set_call.contains(topActivityClassName)) {
                if (alertView.isIs_bind_call()) {
                    lanch_type = LANCH_TYPE_CALL;
                }
            }else if (bind_set_contacts.contains(topActivityClassName)) {
                if (alertView.isIs_bind_contacts()) {
                    lanch_type = LANCH_TYPE_CONTACTS;
                }
            }else if (bind_set_mms.contains(topActivityClassName)) {
                if (alertView.isIs_bind_mms()) {
                    lanch_type = LANCH_TYPE_MMS;
                }
            }
        }
        return lanch_type;
    }
    /**
     * 干掉其他程序，并启动我们的app，<font color="#ff0000">这里code写了，但是没有什么效果，大家有好的杀其他app的办法可以告诉我</font>
     */
    public void killTopAndExcuteMine() {
        if (isSuccess) {
            return;
        }
        int type = checkTopType();
        switch (type) {
            case LANCH_TYPE_CALL:
                startOurApp(TwoActivity.class);
                break;
            case LANCH_TYPE_CONTACTS:
                startOurApp(TwoActivity.class);
                break;
            case LANCH_TYPE_MMS:
                startOurApp(TwoActivity.class);
                break;
            case LANCH_TYPE_NONE:
//                mHandler.removeMessages(TouchHandler.MSG_WHAT_COMMENT);
//                isSuccess = true;
                return;
        }
    }
    /**
     * 启动我们的app
     * @param targetClass
     */
    private void startOurApp(Class<?> targetClass){
        List<RunningTaskInfo> topRunningTask = mActivityManager.getRunningTasks(1);
        if (topRunningTask != null && topRunningTask.size() > 0) {
            RunningTaskInfo topRunningTaskInfo = topRunningTask.get(0);
            String packagename = topRunningTaskInfo.topActivity.getPackageName();
            if (mContext.getPackageName().equals(packagename)) {
                return;
            }
            mActivityManager.killBackgroundProcesses(packagename);
        }
        Intent i = new Intent();
        i.setAction(Intent.ACTION_MAIN);
        i.addCategory(Intent.CATEGORY_DEFAULT);
//        i.addCategory(Intent.CATEGORY_LAUNCHER);
        i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        i.setClassName(mContext, targetClass.getName());
        mContext.startActivity(i);
        isSuccess = true;
    }
    @Override
    protected void onLooperPrepared() {
        Looper localLooper = getLooper();
        this.mHandler = new TouchHandler(this, localLooper);
    }

    @Override
    public boolean quit() {
        this.mHandler = null;
        this.mContext = null;
        return super.quit();
    }

public class TouchHandler extends Handler {
    ……
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_WHAT_COMMENT:
                if (paramd == null){
                    logMsg("TouchEventHandlerThread is null");
                    return;
                }
                paramd.killTopAndExcuteMine();
                break;
            case MSG_WHAT_COMMENT_FAILED:
                logMsg("FAILED");
                break;
            default:
                break;
        }
    }

主要的核心code主要就是上面这些了，具体的流程分析大家可以看我上面留的那么文章和反编译上面几个app来具体分析吧

demo下载地址：http://download.csdn.net/detail/lsmfeixiang/7859557

github地址：https://github.com/teffy/bind-system-app

需要依赖appcompat_v7，大家可以去sdk.dir：android sdk\extras\android\support\v7目录下面找到