RK平台Android4.4 添加一个新的遥控器支持以及添加特殊按键

瑞芯微平台

SDK：Android4.4

好久没写博客了，最近工作中需要在SDK中添加一个新的遥控器支持，由于自己对java代码比较头大，过程也是一波三折，整个流程其实分析下来并不难，这里做个简单的总结。也算是学习android的一个开端。

1.  遥控器红外键值到linux层的映射

      安卓4.4后linux层和红外层的键值映射是在设备树中修改的，不需要在linux中修改驱动代码，直接在相应的dts文件中修改即可，首先每个遥控器都有一个usercode,按照瑞芯微方面提供的文档：

在终端中输入命令：echo 1 > sys/module/cmcc_pwm_remotectl/parameters/code_print

其中USERCODE=0xf601的遥控器用户码，用来标识是哪一个遥控器，RMC_GETDATA=bb，这个是遥控器设备linux驱动中对应的按键上报的对应的键值。

文件目录\kernel\arch\arm\boot\dts\xxx.dts

在代码中先添加如下框架（文件里面照葫芦画瓢）（先把usercode这样加上，然后输入上面的命令才能记录相应按键DTS中对应的值）：

我这上面是修改好的样子，0xbb和0xbc分别对应的是向上键和确定键。这些都是记录的键值，

<0xbc KEY_REPLY>, 其中0xbc在DTS文件中确定键对应的宏定义 KEY_REPLY这个要在input.h文件中去找

input.h文件路径：kernel\arch\arm\boot\dts\include\dt-bindings\input\input.h

DTS文件中每一按键的键值都可以通过打印来记录，每一个键值所对应的宏可以通过linux驱动层中input.h文件中对应的宏找到。名字一定要保持一致！其中上面确定键对应的232是linux层上报android层的键值。

就这样记录所有的按键，然后在DTS文件对号入座，第一步遥控器红外层到linux层的键值映射就搞定了

2. Linux层到android层的键值映射

同样通过终端输入命令：getevent 记录Linux层到android层的键值记录

对应的映射文件就是110b0030_pwm.kl 这个是可以在相关配置文件修改确定是哪个KL文件是linux层到android层键值映射，也可以修改为自己创建的KL文件。

文件目录：盒子根文件目录下的/system/usr/keylayout/110b0030_pwm.kl文件

这里232是确定键从Linux层上报到android层的键值，其中确定键对应的宏DPAD_CENTER 这个可以在keyevent.java文件中找到

一般的遥控器常规按键做到这两步了,基本都没问题了，但是特殊按键的添加还需要继续完善！

通常Linux驱动层基本不需要修改，第一步：我们只需要修改对应的KL文件即可。

已遥控器上的搜索按键为例：

由于DTS文件中：

<0xa7 KEY_PROGRAM>  a7是记录的搜索键的键值， 后边对应的宏是input.h文件中可以找到对应的，这个加进去就好了

KL文件中：

key 362   TV_SEARCH    //362是getevent命令记录的搜索键的键值， TV_SEARCH是自定义的宏，这个名字自己可以随便定义。

第二个修改的地方是keycodes.h文件

文件目录：frameworks\native\include\android\keycodes.h

在文件中添加一个没有用到的键值

第三个修改的地方是KeycodeLables.h文件

文件目录：\frameworks\native\include\input\KeycodeLables.h

第四个修改attrs.xml文件

文件目录：\frameworks\base\core\res\res\values\arrrs.xml

第五个修改的文件：KeyEvent.java    （这个文件修改的地方有两个）

如果添加的是最后一个别忘了LAST_KEYCODE 这个要和最后一个保持一致.下面还有一个地方也要添加：

至此特殊按键搜索按键从红键值外层到android层的键值映射就完成了。搜索按键到android应用层的键值映射就是257.

特殊按键应用层特殊处理可以修改PhoneWindowManager.java文件

文件目录：\frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindowManager.java

特殊按键处理这次应用层的做法是修改PhoneWindowManager.java文件，同时在上面的目录中添加keyfunction.java文件。

package com.android.internal.policy.impl;

import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

import org.w3c.dom.Element;
import org.w3c.dom.Node;
import java.io.Serializable;

import org.xml.sax.SAXException;
import android.os.Looper;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ContextWrapper;
import android.util.Log;
import android.os.Message;
import android.os.Messenger;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.UserHandle;
import android.media.AudioService;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
//import com.hisilicon.android.HiDisplayManager;
//import com.hisilicon.android.DispFmt;
import android.widget.Toast;
import android.view.KeyEvent;
import android.os.SystemProperties;
import android.content.res.Configuration;
import android.app.ActivityManagerNative;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.pm.PackageInfo;
//import android.view.VGAToast;

public class Keyfunction {
    private static Keyfunction mInstance = null;
    private static final String KEYFUNTIONXLMNAME = "/system/etc/keyfunction.xml";
    private static final int MSG_TO_SET_FORMAT = 111;
    private static Context mContext;
//    private HiDisplayManager mDisplayManager = null;
    private ToastUtil toast = null;
    private String mProduc_name = null;
    private final String TAG = "Keyfunction";

    private boolean is4Cpu = true;
    private static ArrayList settingFormatValueList = new ArrayList();
    private static ArrayList settingFormatStringList = new ArrayList();

    private File avplay;
    private int[] threeD_ValueList = {19, 20, 21};
    private String[] threeD_StringList = {"1080P 24Hz FramePacking", "720P 60Hz FramePacking", "720P 50Hz FramePacking"};
    private int[] fourK_ValueList = {0x100, 0x101, 0x102, 0x103};
    private String[] fourK_StringList = {"3840X2160 24Hz", "3840X2160 25Hz", "3840X2160 30Hz", "4096X2160 24Hz"};

    private int nCurrentFormat;
    private boolean currFmtInSets = false;
    private int nCurrentFormatIndex;
    private String CurrentFormatIndexString;

    private boolean bEventWasHandled = true;

    private final long TIME_SPACE = 3000;
    private int mScreenCount = 0;
    private Keyfunction(Context context) {
        Log.e(TAG, "-------->Keyfunction <---------");
        showStartMsg = false;
		mContext = context;
		loadKeyFuntion(mContext);
        toast = new ToastUtil();

        mProduc_name = SystemProperties.get("ro.product.device");
        is4Cpu = mProduc_name.substring(0, 5).equals("Hi379")?true:false;
    }
    public static class ToastUtil {

        private static Handler handler = new Handler(Looper.getMainLooper());

        private static Toast toast = null;

        private static Object synObj = new Object();

        public static void showMessage(final Context act, final String msg) {
            showMessage(act, msg, Toast.LENGTH_SHORT);
        }

        public static void showMessage(final Context act, final int msg) {
            showMessage(act, msg, Toast.LENGTH_SHORT);
        }

        public static void showMessage(final Context act, final String msg,
                final int len) {

            handler.post(new Runnable() {
                @Override
                public void run() {
                    synchronized (synObj) {
                        if (toast != null) {
                            // toast.cancel();
                            toast.setText(msg);
                            toast.setDuration(len);
                        } else {
                            toast = Toast.makeText(act, msg, len);
                        }
                        toast.show();
                    }
                }
            });
        }

        public static void showMessage(final Context act, final int msg,
                final int len) {

            handler.post(new Runnable() {
                @Override
                public void run() {
                    synchronized (synObj) {
                        if (toast != null) {
                            // toast.cancel();
                            toast.setText(msg);
                            toast.setDuration(len);
                        } else {
                            toast = Toast.makeText(act, msg, len);
                        }
                        toast.show();
                    }
                }
            });
        }
    }
    
    private static Keyfunction keyfunction;
	HashMap keyFunctionMap = new HashMap();
	private final boolean showStartMsg;
	
	public static Keyfunction getInstance(Context context) {
		if (keyfunction == null) {
			keyfunction = new Keyfunction(context);
		}
		return keyfunction;
	}

	static int parseToInt(String number) throws Exception {
		int n = -1;
		if (number.startsWith("0x") || number.startsWith("0X")) {
			n = Integer.parseInt(number.substring(2), 16);
		} else {
			n = Integer.parseInt(number);
		}
		return n;
	}

	static int parseToInt(String number, int def) {
		int n = def;
		try {
			n = parseToInt(number);
		} catch (Exception e) {
			return def;
		}
		return n;
	}

	private HashMap loadKeyFuntion(Context mContext) {
		File file = null;
		file = new File(KEYFUNTIONXLMNAME);
		if ((!file.exists()) || (!file.canRead())) {
			keyFunctionMap.clear();
			return keyFunctionMap;
		}
		try {
			keyFunctionMap.clear();
			DocumentBuilderFactory xmlparser = DocumentBuilderFactory.newInstance();
			DocumentBuilder xmlDOC;
			Document doc = null;
			xmlDOC = xmlparser.newDocumentBuilder();
			doc = xmlDOC.parse(file);
			if (null == doc)
				return keyFunctionMap;
			NodeList appItems = doc.getElementsByTagName("key");
			for (int i = 0; i < appItems.getLength(); i++) {
				Node appItem = appItems.item(i);
				if (!appItem.hasChildNodes())
					continue;
				String actionType = ((Element) appItem).getAttribute("actionType");

				NodeList appInfoItems = appItem.getChildNodes();
				AppInfoVO appInfo = new AppInfoVO();
				appInfo.actionType = ((actionType == null || actionType.length() == 0) ? AppInfoVO.ACTION_TYPE_ACTIVITY
						: actionType);
				for (int j = 0; j < appInfoItems.getLength(); j++) {
					Node appInfoItem = appInfoItems.item(j);
					String nodeName = appInfoItem.getNodeName();
					String nodeTextContent = appInfoItem.getTextContent();
					if (nodeName.equalsIgnoreCase("keyName")) {
						appInfo.keyName = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("keyValue")) {
						appInfo.keyValue = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("packageName")) {
						appInfo.packageName = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("activityName")) {
						appInfo.activityName = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("serviceName")) {
						appInfo.serviceName = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("action")) {
						appInfo.action = nodeTextContent;
					} else if (nodeName.equalsIgnoreCase("flags")) {
						appInfo.flags = parseToInt(nodeTextContent, Intent.FLAG_ACTIVITY_NEW_TASK);
					} else if (nodeName.equalsIgnoreCase("method")) {
						appInfo.method = parseToInt(nodeTextContent, AppInfoVO.METHOD_FOR_INTERCEPT);
					} else if (nodeName.equalsIgnoreCase("extras")) {
						if (!appInfoItem.hasChildNodes())
							continue;
						NodeList appExtraItems = appInfoItem.getChildNodes();
						String isBundle = ((Element) appInfoItem).getAttribute("isBundle");
						appInfo.isExtarsBundle = (isBundle != null && isBundle.length() > 0 && ("true"
								.equalsIgnoreCase(isBundle) || isBundle.charAt(0) == '0'));
						appInfo.extras = new HashMap();
						for (int k = 0; k < appExtraItems.getLength(); k++) {
							Node appExtraItem = appExtraItems.item(k);
							if (!(appExtraItem instanceof Element))
								continue;
							// Log.i(TAG,node.getNodeType());
							String type = ((Element) appExtraItem).getAttribute("type");
							String name = appExtraItem.getNodeName();
							String value = appExtraItem.getTextContent();
							parseExtra(appInfo.extras, type, name, value);
						}
					} else if (nodeName.equalsIgnoreCase("exclude")) {
						if (!appInfoItem.hasChildNodes())
							continue;
						NodeList appExtraItems = appInfoItem.getChildNodes();
						appInfo.excludePackage = new ArrayList();
						appInfo.excludeActivity = new ArrayList();
						for (int k = 0; k < appExtraItems.getLength(); k++) {
							Node appExtraItem = appExtraItems.item(k);
							if (!(appExtraItem instanceof Element))
								continue;
							String name = appExtraItem.getNodeName();
							String value = appExtraItem.getTextContent();
							if (name == null || name.length() == 0 || value == null
									|| value.length() == 0) {
								continue;
							}
							if ("packageName".equalsIgnoreCase(name)) {
								appInfo.excludePackage.add(value);
							} else if ("activityName".equalsIgnoreCase(name)) {
								appInfo.excludeActivity.add(value);
							}
						}
					}
				}
				if (appInfo.checkValid()) {
					appInfo.generatIntent();
					Log.i(TAG, "Got keyfunction :\n" + appInfo);
					keyFunctionMap.put(appInfo.keyValue, appInfo);
				}
			}
		} catch (Exception e) {
			Log.e(TAG, "loadKeyFuntionn fail:", e);
		}
		Log.i(TAG, "Got " + keyFunctionMap.size() + " items from the xml file");
		return keyFunctionMap;
	}

	private HashMap parseExtra(HashMap extra, String type,
			String name, String value) {
		Object v = null;
		// Log.i(TAG,"parseExtra s type:" + type + ";" + name + "=" +
		// value);
		try {
			if ("int".equalsIgnoreCase(type)) {
				v = Integer.parseInt(value);
			} else if ("long".equalsIgnoreCase(type)) {
				v = Long.parseLong(value);
			} else if ("double".equalsIgnoreCase(type)) {
				v = Double.parseDouble(value);
			} else if ("float".equalsIgnoreCase(type)) {
				v = Float.parseFloat(value);
			} else if ("boolean".equalsIgnoreCase(type)) {
				v = Boolean.parseBoolean(value);
			} else if ("string".equalsIgnoreCase(type) || "".endsWith(type)) {
				v = value;
			} else {
				Log.i(TAG, "parseExtra  unknown type:" + type);
				v = null;
			}
		} catch (Exception e) {
			Log.i(TAG, "parseExtra  data error :" + e.getMessage());
			v = null;
		}
		// Log.i(TAG,"parseExtra e type:" + type + ";" + name + "=" +
		// (v != null ? v : null));
		if (v != null)
			extra.put(name, v);
		return extra;
	}

	public AppInfoVO getKeyFunction(int keyValue) {
		return keyFunctionMap.get(String.valueOf(keyValue));
	}

	public AppInfoVO getBeforeUserKeyFunction(int keyValue) {
		AppInfoVO app = getKeyFunction(keyValue);
		if (app == null)
			return null;
		if (app.method == AppInfoVO.METHOD_FOR_INTERCEPT
				|| app.method == AppInfoVO.METHOD_FOR_UNINTERCEPT)
			return app;
		return null;
	}

	public AppInfoVO getUserUnhandledKeyFunction(int keyValue) {
		AppInfoVO app = getKeyFunction(keyValue);
		if (app == null)
			return null;
		if (app.method == AppInfoVO.METHOD_FOR_AFTER_USER_UNHANDLED)
			return app;
		return null;
	}
	public boolean isNeedExcludeOnTopComponent(AppInfoVO app, ComponentName cn) {
		boolean exclude = false;
		if (cn != null && app != null) {
			String pck = cn.getPackageName();
			if (pck != null && pck.length() > 0) {
				exclude = app.isExclucePackage(pck);
			}
			String activityName = cn.getClassName();
			if (!exclude && activityName != null && activityName.length() > 0) {
				if(activityName.equals(app.activityName)){
					exclude = true;
					Log.w(TAG, "is current app!! no need run keyfun");
				}
				if (!activityName.contains("."))
					activityName = pck + "." + activityName;
				if (!exclude)
					exclude = app.isExcluceActivity(activityName);
				if (!exclude)
					exclude = app.isExcluceActivity(pck + "." + cn.getShortClassName());
			}
			if (exclude) {
				Log.w(TAG, "no need run keyfun for:" + cn + " app id:" + app.keyValue + " name:" + app.keyName);
			}
		}
		return exclude;
	}
	/**
	 * 
	 * @param app
	 * @return 是否需要拦截
	 */
	public boolean runKeyFunction(AppInfoVO app) {
		boolean needIntercept = false;
		boolean succ = false;
		if (app == null)
			return false;
		if (!keyFunctionMap.containsValue(app))
			return false;
		Log.i(TAG, "runKeyFunction..s app:" + app);
		needIntercept = app.method == AppInfoVO.METHOD_FOR_INTERCEPT;
		Log.i(TAG, "runKeyFunction..needIntercept=" + needIntercept);
		Intent intent = app.getStartIntent();
		try {
			if (intent != null) {
				// intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
				if (AppInfoVO.ACTION_TYPE_ACTIVITY.equalsIgnoreCase(app.actionType)) {
					if (showStartMsg)
						ToastUtil.showMessage(mContext, "startActivity for " + app.keyName + ":"
								+ app.keyValue + "\n" + intent.getComponent());
					mContext.startActivity(intent);
					succ = true;
				} else if (AppInfoVO.ACTION_TYPE_SERVICE.equalsIgnoreCase(app.actionType)) {
					if (showStartMsg)
						ToastUtil.showMessage(mContext, "startService for " + app.keyName + ":"
								+ app.keyValue + "\n" + intent.getComponent());
					ComponentName t = mContext.startService(intent);
					if (t != null)
						succ = true;
				} else if (AppInfoVO.ACTION_TYPE_BOADCAST.equalsIgnoreCase(app.actionType)) {
					if (showStartMsg)
						ToastUtil.showMessage(mContext, "sendBroadcast for " + app.keyName + ":"
								+ app.keyValue + "\n" + intent);
					mContext.sendBroadcast(intent);
					succ = true;
				} else {
					Log.e(TAG, "runKeyFunction unknow intent action");
				}
			}
		} catch (Exception e) {
			succ = false;
			Log.e(TAG, "runKeyFunction fail:", e);
		}
		Log.i(TAG, "runKeyFunction..e succ=" + succ);

		return succ && needIntercept;
	}

	class AppInfoVO {
		public AppInfoVO() {
		}

		public static final String ACTION_TYPE_ACTIVITY = "activity";
		public static final String ACTION_TYPE_SERVICE = "service";
		public static final String ACTION_TYPE_BOADCAST = "broadcast";

		public static final int METHOD_FOR_INTERCEPT = 0;
		public static final int METHOD_FOR_UNINTERCEPT = 1;
		public static final int METHOD_FOR_AFTER_USER_UNHANDLED = 2;

		public boolean checkStringValid(String s) {
			return s != null && s.length() > 0;
		}

		public boolean checkActivity() {
			return ((ACTION_TYPE_ACTIVITY.equalsIgnoreCase(actionType)) && (checkStringValid(action) || (checkStringValid(packageName) && checkStringValid(activityName))));
		}

		public boolean checkService() {
			return ((ACTION_TYPE_SERVICE.equalsIgnoreCase(actionType)) && (checkStringValid(action) || (checkStringValid(packageName) && checkStringValid(activityName))));
		}

		public boolean checkBroadcast() {
			return ((ACTION_TYPE_BOADCAST.equalsIgnoreCase(actionType)) && (checkStringValid(action)));
		}

		public boolean checkValid() {
			boolean succ = checkStringValid(keyValue);
			succ = succ && (checkActivity() || checkService() || checkBroadcast());
			return succ;
		}

		public Intent getStartIntent() {
			return intent;
		}

		public boolean isExclucePackage(String pck) {
			return excludePackage != null && excludePackage.contains(pck);
		}

		public boolean isExcluceActivity(String a) {
			return excludeActivity != null && excludeActivity.contains(a);
		}
		
		private void addIntentExtras(Intent intent, HashMap extra) {
			if (extra == null || extra.size() <= 0)
				return;
			for (String key : extra.keySet()) {
				Object value = extra.get(key);
				Log.i(TAG, "key=" + key + ";value=" + value);
				if (value != null && value instanceof Serializable) {
					Log.i(TAG, "add extra:" + key + "=" + value);
					intent.putExtra(key, (Serializable) value);
				}
			}
		}

		public Intent generatIntent() {
			if (intent != null)
				return intent;
			intent = new Intent();
			if (action != null && action.length() > 0) {
				intent.setAction(action);
			}
			intent.addFlags(flags);
			if (ACTION_TYPE_ACTIVITY.equalsIgnoreCase(actionType)) {
				if (checkStringValid(packageName) && checkStringValid(activityName))
					intent.setClassName(packageName, activityName);
			} else if (ACTION_TYPE_SERVICE.equalsIgnoreCase(actionType)) {
				if (checkStringValid(packageName) && checkStringValid(activityName))
					intent.setClassName(packageName, serviceName);
			} else if (ACTION_TYPE_BOADCAST.equalsIgnoreCase(actionType)) {
				// TODO
			}
			if (isExtarsBundle) {
				// TODO
			} else {
				addIntentExtras(intent, extras);
			}
			return intent;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder();
			sb.append("{{keyValue:" + keyValue + "};");
			sb.append("{keyName:" + keyName + "};");
			sb.append("{actionType:" + actionType + "};");
			sb.append("{flags:0x" + Integer.toHexString(flags) + "};");
			sb.append("{method:" + method + "};");
			sb.append("{action:" + action + "};");
			sb.append("{packageName:" + packageName + "};");
			sb.append("{activityName:" + activityName + "};");
			sb.append("{serviceName:" + serviceName + "};");
			sb.append("{extras:" + extras + "};");
			sb.append("{excludePackage:" + excludePackage + "};");
			sb.append("{excludeActivity:" + excludeActivity + "};");
			sb.append("{intent:" + intent + "}}");
			return sb.toString();
		}

		public String actionType = ACTION_TYPE_ACTIVITY;// TODO
		public int flags = Intent.FLAG_ACTIVITY_NEW_TASK;
		public int method = METHOD_FOR_INTERCEPT;
		public boolean isExtarsBundle = false;
		public String keyValue;
		public String keyName;
		public String packageName;
		public String action;
		public String activityName;
		public String serviceName;
		public HashMap extras;
		public ArrayList excludePackage;
		public ArrayList excludeActivity;
		public Intent intent;
	}
    public void readSwitch() {

    }

    private Handler FMThandler = new Handler() {
        public void handleMessage(Message msg) {
            int i = 0;
            switch (msg.what) {
            case MSG_TO_SET_FORMAT:
                Log.e(TAG, "receive MSG_TO_SET_FORMAT msg");
                for (i = 0; i < settingFormatValueList.size(); i++) {
                    if (settingFormatValueList.get(i) == nCurrentFormat) {
                        break;
                    }
                }
                Log.e(TAG, "nCurrentFormatIndex: "+nCurrentFormatIndex);
                Log.e(TAG, "settingFormatValueList.get(nCurrentFormatIndex): "+settingFormatValueList.get(nCurrentFormatIndex));
                if(nCurrentFormatIndex != i)
                {
//                    mDisplayManager.setFmt(settingFormatValueList.get(nCurrentFormatIndex));
//                    mDisplayManager.SaveParam();
//                    mDisplayManager.setOptimalFormatEnable(0);

                    Intent in = new Intent("com.hisilicon.intent.action.ACTION_FORMAT_CHANGED");
                    mContext.sendBroadcastAsUser(in, UserHandle.ALL);
                }
                bEventWasHandled = true;
                break;
            case 1:

            }
            super.handleMessage(msg);
        }

    };
    public void keyToResolution() {
//	mDisplayManager = new HiDisplayManager();
	FMThandler.removeMessages(1);
	Message message = new Message();
	message.what = 1;
	FMThandler.sendMessage(message);
   }
    public void keySwitchFormat() {
        FMThandler.removeMessages(MSG_TO_SET_FORMAT);

//        mDisplayManager = new HiDisplayManager();
        Message message = new Message();
//        nCurrentFormat = mDisplayManager.getFmt();
        getDisplayFormatList();
        int i;

        Log.e(TAG, "current format is: "+nCurrentFormat);
        Log.e(TAG, "bEventWasHandled is: "+bEventWasHandled);
        if(bEventWasHandled)
        {
            for (i = 0; i < settingFormatValueList.size(); i++)
            {
                if (settingFormatValueList.get(i) == nCurrentFormat)
                {
                    nCurrentFormatIndex = i;
                    currFmtInSets = true;
                    break;
                }
                else
                {
                    currFmtInSets = false;
                    nCurrentFormatIndex = 0;
                }
             }
         }
         else
         {
             currFmtInSets = true;
             nCurrentFormatIndex = (nCurrentFormatIndex + 1)%settingFormatValueList.size();
         }
         Log.e(TAG, "currFmtInSets is: "+currFmtInSets);
         Log.e(TAG, "nCurrentFormatIndex is: "+nCurrentFormatIndex);

         if(currFmtInSets)
         {
             bEventWasHandled = false;
             CurrentFormatIndexString = settingFormatStringList.get(nCurrentFormatIndex);
             toast.showMessage(mContext, CurrentFormatIndexString, Toast.LENGTH_LONG);

             message.what = MSG_TO_SET_FORMAT;
             FMThandler.sendMessageDelayed(message, TIME_SPACE);
         }
         else
         {
             //3d format case
             for (i = 0; i < threeD_ValueList.length; i++)
             {
                 if (threeD_ValueList[i] == nCurrentFormat)
                 {
                    Log.e(TAG, "3d format case");
                    toast.showMessage(mContext, threeD_StringList[i], Toast.LENGTH_SHORT);
                    avplay = new File("/proc/msp/avplay00");
                    if (!avplay.exists()) {
                        Log.e(TAG, "no active avplay");
                        //switch format
                        message.what = MSG_TO_SET_FORMAT;
                        FMThandler.sendMessageDelayed(message, TIME_SPACE);
                    }
                    return;
                 }
             }

             //4k format case
             for (i = 0; i < fourK_ValueList.length; i++)
             {
                 if (fourK_ValueList[i] == nCurrentFormat)
                 {
                    Log.e(TAG, "4k format case");
                    toast.showMessage(mContext, fourK_StringList[i], Toast.LENGTH_SHORT);
                    //switch format
                    message.what = MSG_TO_SET_FORMAT;
                    FMThandler.sendMessageDelayed(message, TIME_SPACE);
                    return;
                 }
             }

         }
    }

    public void getDisplayFormatList()
    {
    	
    }

}

同时在盒子根目录下的/system/etc目录下添加keyfunction.xml配置文件。

	
		>Huikan
		275
		com.ipanel.join.vod.fj
        	com.ipanel.join.vod.ui.BTVChannelListActivity
		android.intent.action.MAIN
		0
		0x14008000 
		
	
	
	
		SEARCH
		257
		com.ipanel.join.vod.fj
        	com.ipanel.join.vod.fj.SearchActionActivity
		android.intent.action.MAIN
		0
		0x14008000 
		
			com.ipanel.join.live.fj
		
		



	
		HD
		170
		com.ipanel.join.live.fj
		com.jiangxi.apps.nclive.LiveActivity
		android.intent.action.MAIN
		0x10200000
		
  		815
 			true
		
	

	
		Love
		256
		com.ipanel.join.live.fj
		com.jiangxi.apps.nclive.LiveActivity
		android.intent.action.MAIN
		0x10200000
		
  		2147483627
 			true
		
	

	
		Settings
		176
		com.ipanel.join.cq.settings
        	com.ipanel.join.cq.settings.SettingActivity
		android.intent.action.MAIN
	
	
	
		Email
		65
		com.ipanel.join.cq.settings
        	com.ipanel.join.cq.settings.activity.MailListActivity
		android.intent.action.MAIN
	

	
		HiPQSetting
		1185
		com.hisilicon.android.pqsetting
		com.hisilicon.android.pqsetting.MainService
		android.intent.action.MAIN
	
	

至此搜索按键从红外层到应用层的映射一直到安卓应用层的处理就全部完毕。这里搜索按键是跳到特殊的APP应用界面。