开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
KeyEvent.java
资源名称：src.zip　[点击查看]
上传用户：luxiaowei
上传日期：2022-06-06
资源大小：58k
文件大小：19k
源码类别：

J2ME

开发平台：

Java

KeyEvent.java：源码内容
  1. package com.framework;
  4. import javax.microedition.lcdui.Canvas;
  6. /*
  7.  * To change this template, choose Tools | Templates
  8.  * and open the template in the editor.
  9.  */
  12. /**
  13.  *
  14.  * @author swaroop_kumar
  15.  */
  16. public class KeyEvent {
  17.     
  18.     
  19.     public static int KEY_SOFT_LEFT;
  20.     public static int KEY_SOFT_RIGHT;
  21.     public static int KEY_SOFT_CENTER;
  22.     public static int BACK_KEY;
  23.      /** 
  24.       * constants for platforms  names 
  25.       */  
  26.      public static final String PLATFORM_MOTOROLA = "motorola";  
  27.      public static final String PLATFORM_NOKIA = "nokia";  
  28.      public static final String PLATFORM_SONY_ERICSSON = "SE";  
  29.      public static final String PLATFORM_SIEMENS = "siemens";  
  30.      public static final String PLATFORM_SAMSUNG = "samsung";  
  31.      public static final String PLATFORM_LG = "LG";  
  32.      public static final String PLATFORM_NOT_DEFINED = "NA";  
  33.      /** Devices having Qwerty keyboard with different gamekey behaviour*/
  34.      private static final String[] _SQwertyDevices = {"SonyEricssonP1i"};
  35.      public static final String PLATFORM_BLACKBERRY = "blackberry";
  36.       /** 
  37.       * current platform name 
  38.       */  
  39.      private static String PLATFORM_NAME; 
  40.      
  41.      private static final int SOFT_KEY_LEFT_SE = -6;  
  42.      private static final int SOFT_KEY_RIGHT_SE = -7;  
  43.      private static final int DELETE_KEY_SE = -8;  
  44.      private static final int INTERNET_KEY_SE = -10;  
  45.       
  46.      private static final int SOFT_KEY_LEFT_SAMSUNG = -6;  
  47.      private static final int SOFT_KEY_RIGHT_SAMSUNG = -7;  
  48.      private static final int DELETE_KEY_SAMSUNG = -8;  
  49.      
  50.      private static final int SOFT_KEY_LEFT_SIEMENS = -1;  
  51.      private static final int SOFT_KEY_RIGHT_SIEMENS = -4;  
  52.      
  53.      private static final int SOFT_KEY_LEFT_NOKIA = -6;  
  54.      private static final int SOFT_KEY_RIGHT_NOKIA = -7;  
  55.      private static final int DELETE_KEY_NOKIA = -8;  
  56.      private static final int SOFT_KEY_MIDLE_NOKIA = -5;  
  57.      
  58.      private static final int SOFT_KEY_LEFT_MOTOROLA = -21;  
  59.      private static final int SOFT_KEY_RIGHT_MOTOROLA = -22;  
  60.      
  61.      private static final int SOFT_KEY_LEFT_MOTOROLA2 = -20;  
  62.      private static final int SOFT_KEY_LEFT_MOTOROLA1 = 21;  
  63.      private static final int SOFT_KEY_RIGHT_MOTOROLA1 = 22;  
  64.      
  65.      private static final int SOFT_KEY_MIDLE_MOTOROLA = -23;  
  66.      
  67.      private static final String SOFT_WORD = "SOFT";  
  68.       // Key management...
  70.     protected static final int DELETE_KEY_BLACKBERRY = 8;
  71.     static int  _keysPressed = 0;
  73.     static int  _keysCurrent  = 0;
  75.     static int _keyCode = 0;
  78.     /**
  79.      * Handles the key pressed event of the mobile.
  80.      * @param pKeyCode Value of the key being pressed down.
  81.      */
  82.      public static void init(Canvas canvas)
  83.      {
  84.          PLATFORM_NAME = getPlatform(canvas);  
  85.          KEY_SOFT_LEFT = getLeftSoftkeyCode(canvas);
  86.          KEY_SOFT_RIGHT= getRightSoftkeyCode(canvas);
  87.          KEY_SOFT_CENTER = getMiddleSoftkeyCode(canvas);
  88.          BACK_KEY = getDeleteKeyCode(canvas);
  89.          try {
  90.             String prop = FrameWorkMidlet.getInstance().getAppProperty("KeyPad-Type");
  91.             if(prop != null && prop.length() > 0)
  92.             {
  93.                 if(Util.equalsIgnoreCase(prop, "QWERTY"))
  94.                 {
  95.                     EditControl.setKeyPadType(EditControl.QWERTY_KEY_PAD);
  96.                 }
  97.             }
  98.          } catch (Exception e) {
  99.          }
  100.          
  101.      }
  102.      
  103.     
  104.     
  105.     
  106.      /** 
  107.       * define real key's C or DELETE code for current platform 
  108.       * 
  109.       * @return code 
  110.       */  
  111.      protected static int getDeleteKeyCode(Canvas canvas) {  
  112.          try {  
  113.              if (PLATFORM_NAME.equals(PLATFORM_MOTOROLA)) {  
  114.    
  115.              } else if (PLATFORM_NAME.equals(PLATFORM_NOKIA)) {  
  116.                  if (canvas.getKeyName(DELETE_KEY_SE).toUpperCase().indexOf("CLEAR") >= 0) {  
  117.                      return DELETE_KEY_NOKIA;  
  118.                  } else {  
  119.                      return DELETE_KEY_NOKIA;  
  120.                  }  
  121.              } else if (PLATFORM_NAME.equals(PLATFORM_SAMSUNG)) {  
  122.                  if (canvas.getKeyName(DELETE_KEY_SAMSUNG).toUpperCase().indexOf("CLEAR") >= 0) {  
  123.                      return DELETE_KEY_SAMSUNG;  
  124.                  }  
  125.              } else if (PLATFORM_NAME.equals(PLATFORM_SIEMENS)) {  
  126.              } else if (PLATFORM_NAME.equals(PLATFORM_SONY_ERICSSON)) {  
  127.                  if (canvas.getKeyName(DELETE_KEY_SE).toUpperCase().indexOf("CLEAR") >= 0) {  
  128.                      return DELETE_KEY_SE;  
  129.                  } else if (canvas.getKeyName(DELETE_KEY_SE).toUpperCase().indexOf("C") >= 0) {  
  130.                      return DELETE_KEY_SE;  
  131.                  } else {  
  132.                      return DELETE_KEY_SE;  
  133.                  }  
  134.              }  
  135.          } catch (Throwable e) {  
  136.              return DELETE_KEY_SE;  
  137.          }  
  138.          return -8;  
  139.      } 
  140.       /** 
  141.       * define real middle soft key code for current platform 
  142.       * 
  143.       * @return code 
  144.       */  
  145.      protected static int getMiddleSoftkeyCode(Canvas canvas) {  
  146.          try {  
  147.              if (PLATFORM_NAME.equals(PLATFORM_MOTOROLA)) {  
  148.                  if (canvas.getKeyName(SOFT_KEY_MIDLE_MOTOROLA).toUpperCase().indexOf("SOFT") >= 0) {  
  149.                      return SOFT_KEY_MIDLE_MOTOROLA;  
  150.                  }  
  151.              } else if (PLATFORM_NAME.equals(PLATFORM_NOKIA)) {  
  152.                  if (canvas.getKeyName(SOFT_KEY_MIDLE_NOKIA).toUpperCase().indexOf("SOFT") >= 0) {  
  153.                      return SOFT_KEY_MIDLE_NOKIA;  
  154.                  }  
  155.              } else if (PLATFORM_NAME.equals(PLATFORM_SAMSUNG)) {  
  156.              } else if (PLATFORM_NAME.equals(PLATFORM_SIEMENS)) {  
  157.              } else if (PLATFORM_NAME.equals(PLATFORM_SONY_ERICSSON)) {  
  158.                  return INTERNET_KEY_SE;  
  159.              }  
  160.          } catch (Throwable e) {  
  161.          }  
  162.          return Canvas.FIRE;  
  163.      }  
  164.       /** 
  165.       * define real right soft key code for current platform 
  166.       * 
  167.       * @return code 
  168.       */  
  169.      protected static int getRightSoftkeyCode(Canvas canvas) {  
  170.          int keyCode = -7;  
  171.          try {  
  172.              if (PLATFORM_NAME.equals(PLATFORM_MOTOROLA)) {  
  173.    
  174.                  String rightSoftMoto1 = "";  
  175.                  try {  
  176.                      rightSoftMoto1 = canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA1).toUpperCase();  
  177.                  } catch (IllegalArgumentException ilae) {  
  178.  //                    ilae.printStackTrace();  
  179.                  }  
  180.                  String rightSoftMoto = "";  
  181.                  try {  
  182.                      rightSoftMoto = canvas.getKeyName(SOFT_KEY_RIGHT_MOTOROLA).toUpperCase();  
  183.                  } catch (IllegalArgumentException ilae) {  
  184.  //                    ilae.printStackTrace();  
  185.                  }  
  186.                  String rightSoftMoto2 = "";  
  187.                  try {  
  188.                      rightSoftMoto2 = canvas.getKeyName(SOFT_KEY_RIGHT_MOTOROLA1).toUpperCase();  
  189.                  } catch (IllegalArgumentException ilae) {  
  190.  //                    ilae.printStackTrace();  
  191.                  }  
  192.                  if (rightSoftMoto.indexOf(SOFT_WORD) >= 0 && rightSoftMoto.indexOf("2") >= 0) {  
  193.                      return SOFT_KEY_RIGHT_MOTOROLA;  
  194.                  } else if (rightSoftMoto1.indexOf(SOFT_WORD) >= 0 && rightSoftMoto1.indexOf("2") >= 0) {  
  195.                      return SOFT_KEY_RIGHT_MOTOROLA;  
  196.                  } else if (rightSoftMoto2.indexOf(SOFT_WORD) >= 0 && rightSoftMoto2.indexOf("2") >= 0) {  
  197.                      return SOFT_KEY_RIGHT_MOTOROLA1;  
  198.                  } else if (rightSoftMoto.indexOf(SOFT_WORD) >= 0 && rightSoftMoto.indexOf("RIGHT") >= 0) {  
  199.                      return SOFT_KEY_LEFT_MOTOROLA;  
  200.                  } else if (rightSoftMoto1.indexOf(SOFT_WORD) >= 0 && rightSoftMoto1.indexOf("RIGHT") >= 0) {  
  201.                      return SOFT_KEY_RIGHT_MOTOROLA1;  
  202.                  } else if (rightSoftMoto2.indexOf(SOFT_WORD) >= 0 && rightSoftMoto2.indexOf("RIGHT") >= 0) {  
  203.                      return SOFT_KEY_RIGHT_MOTOROLA;  
  204.                  }  
  205.    
  206.              } else if (PLATFORM_NAME.equals(PLATFORM_NOKIA)) {  
  207.                  return SOFT_KEY_RIGHT_NOKIA;  
  208.              } else if (PLATFORM_NAME.equals(PLATFORM_SAMSUNG)) {  
  209.  //                String rightSoftSamsung = adaptorCanvas.getKeyName(SOFT_KEY_RIGHT_SAMSUNG).toUpperCase();  
  210.  //                if (rightSoftSamsung.indexOf(SOFT_WORD) >= 0) {  
  211.  //                    if (rightSoftSamsung.indexOf("2") >= 0) {  
  212.                  return SOFT_KEY_RIGHT_SAMSUNG;  
  213.  //                    } else if (rightSoftSamsung.indexOf("RIGHT") >= 0) {  
  214.  //                        return SOFT_KEY_RIGHT_SAMSUNG;  
  215.  //                    }  
  216.  //                }  
  217.              } else if (PLATFORM_NAME.equals(PLATFORM_SIEMENS)) {  
  218.                  String rightSoftSiemens = canvas.getKeyName(SOFT_KEY_RIGHT_SIEMENS).toUpperCase();  
  219.                  if (rightSoftSiemens.indexOf(SOFT_WORD) >= 0) {  
  220.                      if (rightSoftSiemens.indexOf("4") >= 0) {  
  221.                          return SOFT_KEY_RIGHT_SIEMENS;  
  222.                      } else if (rightSoftSiemens.indexOf("RIGHT") >= 0) {  
  223.                          return SOFT_KEY_RIGHT_SIEMENS;  
  224.                      }  
  225.                  }  
  226.              } else if (PLATFORM_NAME.equals(PLATFORM_SONY_ERICSSON)) {  
  227.                  return SOFT_KEY_RIGHT_SE;  
  228.              } else if (PLATFORM_NAME.equals(PLATFORM_NOT_DEFINED)) {  
  229.                  for (int i = -125; i <= 125; i++) {  
  230.                      if (i == 0) {  
  231.                          i++;  
  232.                      }  
  233.                      String keyName = canvas.getKeyName(i).toUpperCase();  
  234.                      if (keyName.indexOf(SOFT_WORD) >= 0) {  
  235.                          if (keyName.indexOf("2") >= 0) {  
  236.                              keyCode = i;  
  237.                              break;  
  238.                          } else if (keyName.indexOf("4") >= 0) {  
  239.                              keyCode = i;  
  240.                              break;  
  241.                          } else if (keyName.indexOf("RIGHT") >= 0) {  
  242.                              keyCode = i;  
  243.                              break;  
  244.                          }  
  245.                      }  
  246.                  }  
  247.              }  
  248.          } catch (Throwable iaEx) {  
  249.              //if emulator  
  250.              return SOFT_KEY_RIGHT_NOKIA;  
  251.              //endif  
  252.          }  
  253.          return keyCode;  
  254.      } 
  255.        /** 
  256.       * define real left soft key code by platform 
  257.       * 
  258.       * @return code 
  259.       */  
  260.      protected static int getLeftSoftkeyCode(Canvas canvas) {  
  261.          int keyCode = -6;  
  262.          try {  
  263.              if (PLATFORM_NAME.equals(PLATFORM_MOTOROLA)) {  
  264.                  String softkeyLeftMoto = "";  
  265.                  try {  
  266.                      softkeyLeftMoto = canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA).toUpperCase();  
  267.                  } catch (IllegalArgumentException ilae) {  
  268.  //                    ilae.printStackTrace();  
  269.                  }  
  270.                  String softkeyLeftMoto1 = "";  
  271.                  try {  
  272.                      softkeyLeftMoto1 = canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA1).toUpperCase();  
  273.                  } catch (IllegalArgumentException ilae) {  
  274.  //                    ilae.printStackTrace();  
  275.                  }  
  276.                  String softkeyLeftMoto2 = "";  
  277.                  try {  
  278.                      softkeyLeftMoto2 = canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA2).toUpperCase();  
  279.                  } catch (IllegalArgumentException ilae) {  
  280.  //                    ilae.printStackTrace();  
  281.                  }
  282.                   
  283.                  if (softkeyLeftMoto.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto.indexOf("1") >= 0) {  
  284.                      return SOFT_KEY_LEFT_MOTOROLA;  
  285.                  } else if (softkeyLeftMoto1.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto1.indexOf("1") >= 0) {  
  286.                      return SOFT_KEY_LEFT_MOTOROLA1;  
  287.                  } else if (softkeyLeftMoto2.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto2.indexOf("1") >= 0) {  
  288.                      return SOFT_KEY_LEFT_MOTOROLA2;  
  289.                  } else if (softkeyLeftMoto.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto.indexOf("LEFT") >= 0) {  
  290.                      return SOFT_KEY_LEFT_MOTOROLA;  
  291.                  } else if (softkeyLeftMoto1.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto1.indexOf("LEFT") >= 0) {  
  292.                      return SOFT_KEY_LEFT_MOTOROLA1;  
  293.                  } else if (softkeyLeftMoto2.indexOf(SOFT_WORD) >= 0 && softkeyLeftMoto2.indexOf("LEFT") >= 0) {  
  294.                      return SOFT_KEY_LEFT_MOTOROLA2;  
  295.                  }  
  296.    
  297.              } else if (PLATFORM_NAME.equals(PLATFORM_NOKIA)) {  
  298.                  return SOFT_KEY_LEFT_NOKIA;  
  299.              } else if (PLATFORM_NAME.equals(PLATFORM_SAMSUNG)) {  
  300.  //                String leftkeySamsungName = adaptorCanvas.getKeyName(SOFT_KEY_LEFT_SAMSUNG).toUpperCase();  
  301.  //                if (leftkeySamsungName.indexOf(SOFT_WORD) >= 0) {  
  302.  //                    if (leftkeySamsungName.indexOf("1") >= 0) {  
  303.                  return SOFT_KEY_LEFT_SAMSUNG;  
  304.  //                    } else if (leftkeySamsungName.indexOf("LEFT") >= 0) {  
  305.  //                        return SOFT_KEY_LEFT_SAMSUNG;  
  306.  //                    }  
  307.  //                }  
  308.              } else if (PLATFORM_NAME.equals(PLATFORM_SIEMENS)) {  
  309.                  String leftKeySiemensName = canvas.getKeyName(SOFT_KEY_LEFT_SIEMENS).toUpperCase();  
  310.                  if (leftKeySiemensName.indexOf(SOFT_WORD) >= 0) {  
  311.                      if (leftKeySiemensName.indexOf("1") >= 0) {  
  312.                          return SOFT_KEY_LEFT_SIEMENS;  
  313.                      } else if (leftKeySiemensName.indexOf("LEFT") >= 0) {  
  314.                          return SOFT_KEY_LEFT_SIEMENS;  
  315.                      }  
  316.                  }  
  317.              } else if (PLATFORM_NAME.equals(PLATFORM_SONY_ERICSSON)) {  
  318.                  return SOFT_KEY_LEFT_SE;  
  319.              } else if (PLATFORM_NAME.equals(PLATFORM_NOT_DEFINED)) {  
  320.                  //  
  321.                  for (int i = -125; i <= 125; i++) {  
  322.                      if (i == 0) {  
  323.                          i++;  
  324.                      }  
  325.  //                    System.out.println(getKeyName(i).toUpperCase());  
  326.                      final String s = canvas.getKeyName(i).toUpperCase();  
  327.                      if (s.indexOf(SOFT_WORD) >= 0) {  
  328.                          if (s.indexOf("1") >= 0) {  
  329.                              keyCode = i;  
  330.                              break;  
  331.                          }  
  332.                          if (s.indexOf("LEFT") >= 0) {  
  333.                              keyCode = i;  
  334.                              break;  
  335.                          }  
  336.                      }  
  337.                  }  
  338.              }  
  339.              if (keyCode == 0) {  
  340.                  //if emulator  
  341.                  return SOFT_KEY_LEFT_NOKIA;  
  342.                  //endif  
  343.              }  
  344.          } catch (Throwable iaEx) {  
  345.              //if emulator  
  346.              return SOFT_KEY_LEFT_NOKIA;  
  347.              //endif  
  348.          }  
  349.          return keyCode;  
  350.      }  
  351.       /** 
  352.       * Returns mobile phone platform 
  353.       * 
  354.       * @return name mobile phone platform 
  355.       */  
  356.      private static String getPlatform(Canvas canvas) {  
  357.          // detecting NOKIA or SonyEricsson  
  358.          try {  
  359.              final String currentPlatform = System.getProperty("microedition.platform");  
  360.              if (currentPlatform.indexOf("Nokia") != -1) {  
  361.                  return PLATFORM_NOKIA;  
  362.              } else if (currentPlatform.indexOf("SonyEricsson") != -1) {  
  363.                  return PLATFORM_SONY_ERICSSON;  
  364.              }  
  365.          } catch (Throwable ex) {  
  366.          }  
  367.          // detecting SAMSUNG  
  368.          try {  
  369.              Class.forName("com.samsung.util.Vibration");  
  370.              return PLATFORM_SAMSUNG;  
  371.          } catch (Throwable ex) {  
  372.          }  
  373.          // detecting MOTOROLA  
  374.          try {  
  375.              Class.forName("com.motorola.multimedia.Vibrator");  
  376.              return PLATFORM_MOTOROLA;  
  377.          } catch (Throwable ex) {  
  378.              try {  
  379.                  Class.forName("com.motorola.graphics.j3d.Effect3D");  
  380.                  return PLATFORM_MOTOROLA;  
  381.              } catch (Throwable ex2) {  
  382.                  try {  
  383.                      Class.forName("com.motorola.multimedia.Lighting");  
  384.                      return PLATFORM_MOTOROLA;  
  385.                  } catch (Throwable ex3) {  
  386.                      try {  
  387.                          Class.forName("com.motorola.multimedia.FunLight");  
  388.                          return PLATFORM_MOTOROLA;  
  389.                      } catch (Throwable ex4) {  
  390.                      }  
  391.                  }  
  392.              }  
  393.          }  
  394.          try {  
  395.              if (canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA).toUpperCase().indexOf(SOFT_WORD) > -1) {  
  396.                  return PLATFORM_MOTOROLA;  
  397.              }  
  398.          } catch (Throwable e) {  
  399.              try {  
  400.                  if (canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA1).toUpperCase().indexOf(SOFT_WORD) > -1) {  
  401.                      return PLATFORM_MOTOROLA;  
  402.                  }  
  403.              } catch (Throwable e1) {  
  404.                  try {  
  405.                      if (canvas.getKeyName(SOFT_KEY_LEFT_MOTOROLA2).toUpperCase().indexOf(SOFT_WORD) > -1) {  
  406.                          return PLATFORM_MOTOROLA;  
  407.                      }  
  408.                  } catch (Throwable e2) {  
  409.                  }  
  410.              }  
  411.          }  
  412.          // detecting SIEMENS  
  413.          try {  
  414.              Class.forName("com.siemens.mp.io.File");  
  415.              return PLATFORM_SIEMENS;  
  416.          } catch (Throwable ex) {  
  417.          }  
  418.          // detecting LG  
  419.          try {  
  420.              Class.forName("mmpp.media.MediaPlayer");  
  421.              return PLATFORM_LG;  
  422.          } catch (Throwable ex) {  
  423.              try {  
  424.                  Class.forName("mmpp.phone.Phone");  
  425.                  return PLATFORM_LG;  
  426.              } catch (Throwable ex1) {  
  427.                  try {  
  428.                      Class.forName("mmpp.lang.MathFP");  
  429.                      return PLATFORM_LG;  
  430.                  } catch (Throwable ex2) {  
  431.                      try {  
  432.                          Class.forName("mmpp.media.BackLight");  
  433.                          return PLATFORM_LG;  
  434.                      } catch (Throwable ex3) {  
  435.                      }  
  436.                  }  
  437.              }  
  438.          }  
  439.          return PLATFORM_NOT_DEFINED;  
  440.      }  
  441.   protected static boolean isNumericKeyPad(Canvas canvas)
  442.   {
  443.      
  444.       try {
  445.             for (int i = 65; i < (65 + 26); i++)
  446.             {
  447.               canvas.getKeyName(i);
  448.             }
  449.             if(canvas.getGameAction((int)'A') == Canvas.LEFT && canvas.getGameAction((int)'D') == Canvas.RIGHT && canvas.getGameAction((int)'W') == Canvas.UP && canvas.getGameAction((int)'Z') == Canvas.DOWN)
  450.             {
  451.                 return false;
  452.             }
  453.             String platform = System.getProperty("microedition.platform"); 
  454.             for(int devCnt=0; devCnt<_SQwertyDevices.length; devCnt++){
  455.                 if(platform.indexOf(_SQwertyDevices[devCnt]) != -1){
  456.                     return false;
  457.                 }
  458.             }
  459.             return true;
  460.       } catch (Exception e) {
  461.            return true;
  462.       }
  463.   }
  464. }