IT博客-kenlistian-随笔分类-Java

网站点播业务流程

kenlistian — Fri, 27 Jun 2008 04:27:00 GMT

kenlistian 2008-06-27 12:27 发表评论

j2me笔记7

kenlistian — Tue, 24 Jun 2008 14:27:00 GMT

把关于序列化的章节整理了下，大致了解了使用RMS类的方法。
至于如何在代码中实现，今个儿没时间搞。先放放。

MIDP2.0 规范里提供了RMS
以一种简单的，类似表格的形式组织信息，并存储起来形成持久化存储。

理解Records(记录)和 Records Stores(记录仓储)两个概念。

记录仓储(Records Stores)类似于数据库的表 table。
名称大小不能超过 32 个Unicode 字符，同一个Suite下的MIDlet 都可以共享这些记录仓储。

记录即表中记录。
记录(Record)由一整型的 RecordID 与一代表数据的 byte[]数组两个子元素组成。
RecordID 是记录的唯一标志符，就相当是数据表中递增的id关键字。

调用javax.microedition.rms即操作数据存储。
该包中有一主类，四个接口，以及五个可能的被抛出异常。

打开

通过openRecordStore()来取得实例。

openRecordStore (String recordStoreName, boolean createIfNecessary)
openRecordStore (String recordStoreName, boolean createIfNecessary,int authmode), boolean writable))
openRecordStore (String recordStoreName, String vendorName, String suiteName)

第一个参数是记录仓储的名称，
第二个参数表明了当我们请求的仓储不存在时，是否新建一 Record Store;
第三个参数表明了此仓储的读取权限，
第四个参数则决定了写入权限。

当用第一个方法时，则选择读取权限只限于本地，且拒绝其他MIDlet写数据到记录仓储上。
即相当于使用第二种开启方法并分别为第三第四个参数传入了RecordStore.AUTHMODE_PRIVATE 和 false。

第三openRecordStore 读取其他 MIDlet Suite 记录仓储。
传入参数为记录仓储名，发布商名以及 MIDlet Suite 套件名。

注意，如该储的读取权限为 AUTHMODE_PRIVATE 的话，此方法将返回安全错误。

用第一种方法的示例：
private RecordStore rs = null;
try {
   //打开一个RMS，如果打开失败，则创建
   rs = RecordStore.openRecordStore(“testRMS”, true);
}
catch (RecordStoreNotFoundException e) {
      e.printStackTrace();

}
catch (RecordStoreFullException e) {
      e.printStackTrace();
}
catch (RecordStoreException e) {
   e.printStackTrace();
}

关闭 closeRecordStore()

打开需要关闭，就如同你new一个内存，要记得delete，不要指望自动回收功能。

try {
rs = RecordStore.openRecordStore(“testRMS”, true);

   //.....
   rs.closeRecordStore();
}
   catch (RecordStoreNotOpenException e) {
   e.printStackTrace();
} catch (RecordStoreException e) {
   e.printStackTrace();
}

删除deleteRecordStore()

在删除之前，确保当前的仓储是处于关闭状态，否则抛异常。
如下

//假定rs是已经存在的记录仓储，并已经打开
try
{
rs.closeRecordStore();
RecordStore.deleteRecordStore(“testRMS”);

}
catch (RecordStoreNotOpenException e) {
e.printStackTrace();
}
catch (RecordStoreNotFoundException e) {
e.printStackTrace();
} catch (RecordStoreFullException e) {
e.printStackTrace();
} catch (RecordStoreException e) {
   e.printStackTrace();
}

插入 addRecord(byte[] data, int offset, int numBytes)

添加byte数组类型的数据。
参数为byte[]数组，传入 byte[]数组起始位置，传入数据的长度

数据添加成功后， addRecord 将返回记录 ID号（RecordID），

添加操作是一个原子操作。但在又读又写是同步的。

删除 deleteRecord(int recordId)，

如试图从未开启的记录仓储中删除记录，返回RecordStoreNotOpenException异常；
如果传入ID无效的，返回 InvalidRecordIDException异常；

修改指定ID的记录值
setRecord(int recordId, byte[] newData, int offset, int numBytes)

针对 RecordStore 的操作只提供对针对 byte 数组的服务.
遇到的都将是非 byte 类型。

采用流文件类来处理。

非byte-->byte
ByteArrayOutputStream，
DataOutputStream，

byte-->非byte
ByteArrayInputStream，
DataInputStream

示例

首先写入一组自定义数据，然后在读出：
  ByteArrayOutputStream baos = new ByteArrayOutputStream(); //构建一个转换成byte字节的流
  DataOutputStream dos = new DataOutputStream(baos);          //构建写入流的数据类

  dos.writeBoolean(false);
  dos.writeInt(15);
  dos.writeUTF("abcde");

  byte [] data = baos.toByteArray();//取得byte数组
  dos.close();
  baos.close();


  ByteArrayInputStream bais = new ByteArrayInputStream(data); //构建一字节写入流
  DataInputStream dis = new DataInputStream(bais);          //能读流数据类

  boolean flag = dis.readBoolean();
  int intValue = dis.readInt();
  String strValue = dis.readUTF();
  dis.close();
  bais.close();

用RMS实现对象序列化
下面展示单词记录本，构建一个word类数据结构

public class Word {
  private String  enWord; //英文单词
  private String  cnWord; //解释
  private long dateTime; //读取时间
  private String  detail; //备注信息
}

读出和写入调用serialize,deserialize
serialize 用于序列化对象数据，返回 byte 数组类型；
deserialize 完成的则是相反的工作。

/*
  生成序列化的byte数组数据
*/
  public byte[] serialize() throws IOException{

ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);

dos.writeUTF(this.enWord);
dos.writeUTF(this.cnWord);
dos.writeLong(this.dateTime);
dos.writeUTF(this.detail);

baos.close();
dos.close();
return baos.toByteArray();
}

/* 将传入的byte类型数据反序列化为已知数据结构
*/
  public static Word deserialize(byte[] data) throws IOException{

ByteArrayInputStream bais = new ByteArrayInputStream(data);
DataInputStream dis = new DataInputStream(bais);

Word word = new Word();
word.enWord = dis.readUTF();
word.cnWord = dis.readUTF();
word.dateTime = dis.readLong();
word.detail = dis.readUTF();

bais.close();
dis.close();
return word;

  }

RecordStore的更多操作

看
RecordComparator，
RecordEnumeration，
RecordFilter
RecordListener。

考虑到 RecordComparator、RecordFilter 都是作用在 RecordEnumeration 上的，我们先来介
绍这个接口。

RecordEnumeration遍历接口
采用for方式，由于RecordId所对应的记录并不见得存在，故采用RecordEnumeration 接口。
有点类似迭加器了。

enumerateRecords()：
通过对 RecordStore 实例对象调用 enumerateRecords 方法来取得一个 RecordEnumeration 的
实例。
其可传入 3 个参数：filter，comparator与 keepUpdated。

前两个参数分别是过滤器和排序策略，
这个后面会讲到。

当传入的 filter不为空时，它将用于决定记录仓储中的哪些记录将被使用；
当 comparator 不为空时，RecordStore将按照我们指定的排列顺序返回。
第三个参数决定了当遍历器建立起来以后，是否对记录仓储新的改变做出回应。
如果传入 true，那么将有一个 RecordListener 被加入到 RecordStore 中，使得记录仓储的内容与
RecordEnumeration 随时保持同步。
如果传入 false，则可以使得当前遍历更有效率，但所取得的RecordID 集合仅仅是调用此方法这个时刻的RecordStore 快照。

此后对 RecordStore 所有更改都不会反应在这个集合上。
请读者根据要求在访问数据完整性和访问速度之间进行取舍。

numRecords()：       返回了在当前遍历集合中，可用记录数目。这里所指的可用，不仅仅是说RecordID
                     对应的记录存在；当 filter存在时，也需要符合过滤条件。

hasNextElement()：    判断在 RecordEnumeration 当前指向的下一个位置，还有没有剩余记录了。

hasPreviousElement()：  判断在 RecordEnumeration当前指向的前一个位置，还有没有剩余记录了。

nextRecord()：          返回了遍历器下一位置的记录拷贝，由于返回的是拷贝，
                     所以任何对返回记录的修改都不会影响到记录仓储的实际内容。

nextRecordId()：       返回当前遍历器下一位置记录的RecordID，当下一位置没有可用的记录时，
                     继续调用nextRecordId将抛出异常 InvalidRecordIDException。

添加一个方法 ViewAll()，用来返回当前记录仓储中的所有单词
如何利用 RecordEnumeration 来遍历记录。

public Word[] viewAll() throws IOException {
Word[] words = new Word[0];
RecordEnumeration re = null;

//rs是之前创建的RecordStore类型实例变量
if (rs == null)
      return words;

try {
   re = rs.enumerateRecords(null, new WordComparator(), false);
   //无过滤器、但有一个排序策略
   words = new Word[re.numRecords()];
   int wordRecords = 0;

   while (re.hasNextElement()) {
      byte[] tmp = re.nextRecord();
      words[wordRecords] = Word.deserialize(tmp);
      wordRecords++;
   }
}
catch (RecordStoreNotOpenException e1) {
   e1.printStackTrace();
}
catch (InvalidRecordIDException e1) {
   e1.printStackTrace();
}
catch (RecordStoreException e1) {
   e1.printStackTrace();
}
finally {
   if (re != null)
      re.destroy();
}
return words;
}

RecordFilter 过滤接口
  过滤接口是用来过滤不满足条件的记录的。
  要实现match(byte[] candidate)方法，当传入 byte 数据符合筛选条件时，返回 true。

  WordFilter 实现 RecordFilter 接口。

  public class WordFilter implements RecordFilter
  {
private String  enWord;
private int    type;
public WordFilter(String enword, int type){

//传入要比较的项，type指向一个自定义的内部事件标记
//表现为整形
   this.enWord = enword;
   this.type = type;
}

public boolean matches(byte[] word) {
//matches方法中传入的参数是RMS中的各个候选值（元素）
try {

   if(type == EventID.SEARCH_EQUAL){
         return Word.matchEN(word, enWord);
   }
   else{
      return Word.matchEN_StartWith(word, enWord);
   }
}
catch (IOException e) {
   e.printStackTrace();
   return false;
}
}
}

示例中的 EventID.SEARCH_EQUAL 为一个定义好的整型数据；
同时，这里涉及到了Word 类的两个对应方法：

public static boolean matchEN_StartWith(byte[] data, String enword) throws IOException
{
ByteArrayInputStream bais = new ByteArrayInputStream(data);
DataInputStream dis = new DataInputStream(bais);
try{
      return (dis.readUTF().startsWith(enword));

   }catch(IOException e){
      e.printStackTrace();
      return false;
   }
}

public static boolean matchCN(byte[] data, String cnword) throws IOException
{
ByteArrayInputStream bais = new ByteArrayInputStream(data);
DataInputStream dis = new DataInputStream(bais);
try{
      dis.readUTF();
      return (dis.readUTF().equals(cnword));
}catch(IOException e){
   e.printStackTrace();
   return false;
}
}

RecordComparator比较接口

比较器定义了一个比较接口，用于比较两条记录是否匹配，或符合一定的逻辑关系。

须实现compare方法
compare(byte[] rec1,  byte[] rec2)
当rec1 在次序上领先于rec2 时，返回RecordComparator.PRECEDES；
反之则返回RecordComparator.FOLLOWS；
参数相等，返回RecordComparator.EQUIVALENT。

private static class WordComparator implements RecordComparator{

   public int compare(byte[] word_1, byte[] word_2) {

   try {
      Word word1 = Word.deserialize(word_1);
      Word word2 = Word.deserialize(word_2);
      long dateTime1 = word1.getDateTime();
      long dateTime2 = word2.getDateTime();

      if(dateTime1 < dateTime2){
         return RecordComparator.FOLLOWS;
      }

if(dateTime1 > dateTime2){
      return RecordComparator.PRECEDES;
      }
      return RecordComparator.EQUIVALENT;
   }
   catch (IOException e)
   {
      e.printStackTrace();
   }
   return 0;
}
}

RecordListener 监听器接口

RecordListener是用于接受监听记录仓储中记录添加，更改或删除记录等事件的接口。
利用 RecordStore 的addRecordListener 方法来注册一个监听器。
使用监听器必须实现 3 个方法：
recordAdded，
recordChanged
recordDeleted，

都需传入两个参数：记录仓储名称 recordStroe 与记录号recordId。

  recordAdded：当一条新的记录被添加到仓储空间的时候，该方法被触发。
  recordChanged：当一条记录被修改时使用。
  recordDeleted：当一条记录从记录仓储中删除时调用。

注意，RecordListener 是在对记录仓储的操作动作完成以后被调用的！
特别在recordDeleted 方法中，由于传入的记录已经删除，如再使用
getRecord()试图取得刚刚被删除记录的话，会抛出 InvalidRecordIDException 异常。

  getLastModified()：返回记录仓储最后更新时间。
  getName()：          返回一个已经打开了的记录仓储名称。
  getNumRecords()：    返回当前仓储中记录总数。
  getSizeAvailable()：  返回当前仓储中可用的字节数。
  getVersion()：       返回记录仓储版本号。
  listRecordStores()：  获取该MIDlet套件中所有的记录仓储列表。

kenlistian 2008-06-24 22:27 发表评论

j2me 笔记6---canvas初步认识。

kenlistian — Mon, 23 Jun 2008 13:36:00 GMT

依旧是拿例子来学习，再翻一翻讲解，就大致了解一个程序的架构。

在用Canvas写手机界面，其实不过就是自画图而已，在wtk中有个minicolor的例子，
用的是canvas类，其中也讲解了相关的知识点。
这里罗列下几个知识点：

调用repaint()产生重绘事件。

底层事件分为三类：
Press Events 按键事件
Action Keys   动作按键
PointerEvents 触控事件

按键事件
keyPressed()
keyReleased()
keyRepeated()

在RepeatEvents 不是 JTWI 要求强制支持的，故需调用hasRepeatEvents判定。

   当按下按键都会触发 keyPressed()函数，并传入相应位置的整数值，
   有KEY_NUM0- KEY_NUM9 十个常数分别代表键盘上的 0-9,及其两个功能键，
   KEY_STAR,KEY_POUND, 若传入的值小于 0，则为不合法的 keycode

动作按键主要针对游戏来设计的，
有如下：
UP,DOWN,LEFT,RIGHT,
GAME_A,GAME_B,GAME_C,GAME_D,
当按下这些按键时会映射到为每个按键事件编写的方法，来完成一些动作。
在MIDP2.0里已有游戏开发包了可供学习。

触控事件主要面向高端设备，并非 JTWI 要求强制支持的，

pointerPressed(),
pointerReleased(),
pointerDragged()，

对应移动设备手写笔的点，击，拖拽几个动作。参考 WTK的说明文档

在运行minicolor demo,老方法，创建该工程文件，及其同名类。（可以自命名）
注意一点的是：
在wtk中，无法直接调用canvas类，而需要一个midlet外包类来调用canvas类创建，
其方法也不过一个midlet框架，在其startApp()中调用Canvas实例类。
框架代码如下：

  import   javax.microedition.midlet.*;
  import   javax.microedition.lcdui.*;

  public   class   testCanvas extends MIDlet{

  private   Display   display;

  public   testCanvas()
  {
     display=Display.getDisplay(this);
  }

  public   void   startApp()
{
     //这里调用canvas实例类，在独立一个同目录minicolorchooser.java文件。
     MiniColorChooser testCanvas = new MiniColorChooser();
     display.setCurrent(testCanvas);
}

  public   void   pauseApp(){

  }
  public   void   destroyApp(boolean   unconditional){
  }

  }

其中MiniColorChooser.java文件代码如下，加了注释，

import javax.microedition.lcdui.*;

/**
  一个设置手机背景颜色的Canvas实现类
*/
public class MiniColorChooser extends Canvas {

    /** 条状宽度 */
    static final int BORDER = 2;

    /** 颜色条高度 */
    static final int BAR_H = 14;

    int rgbColor;
    int ndx = 0;

    public MiniColorChooser() {
        setColor(0xffff00);
    }

    public void setColor(int RGB) {
        rgbColor = RGB & 0x00ffffff;
    }

    /**
      颜色值是这样格式：  0x00RRGGBB
     */
    public int getColor() {
        return rgbColor;
    }

    //画背景，修改界面全在这里
    protected void paint(Graphics g) {
        int w = getWidth();
        int h = getHeight();

        int sample_w = w - 1;
        int sample_h = h - ((BAR_H + BORDER) * 3);      //界面高- 3* 条状颜色栏
        int sample_y = BORDER;

        //调颜色栏的蓝，绿，红的y坐标位置
        int b_y = sample_y + sample_h + (BORDER * 2);
        int g_y = b_y + BAR_H;
        int r_y = g_y + BAR_H;

        //先把界面涂为黑板色
        g.setColor(0x000000);
        g.fillRect(0, 0, w, h);

        //再画调色板区域。x0=2，y0=2, x1=背景宽, y1=sample_h
        g.setColor(rgbColor);
        g.fillRect(BORDER, sample_y, sample_w, sample_h);

        //画颜色调节栏，先蓝色
        int blue = (rgbColor >> 0) & 0xff;
        g.setColor(0, 0, 255);
        g.fillRect(20, b_y, blue / 4, 10);

        //绿
        int green = (rgbColor >> 8) & 0xff;
        g.setColor(0, 255, 0);
        g.fillRect(20, g_y, green / 4, 10);

        int red = (rgbColor >> 16) & 0xff;
        g.setColor(255, 0, 0);
        g.fillRect(20, r_y, red / 4, 10);

        //写blue ,green ,red 颜色数值
        g.setColor(255, 255, 255);
        g.drawString(Integer.toString(blue), 18, b_y - 3, Graphics.RIGHT | Graphics.TOP);
        g.drawString(Integer.toString(green), 18, g_y - 3, Graphics.RIGHT | Graphics.TOP);
        g.drawString(Integer.toString(red), 18, r_y - 3, Graphics.RIGHT | Graphics.TOP);

        //画调节颜色栏边框，注意，画边框，
        //ndx = 0,1,2,则分别对应当前激活的调节栏。
        if (ndx >= 0) {
            int y = b_y + (ndx * BAR_H);
            g.drawRect(20, y, 63, 10);
        }
    }

    //当按键不松时
    public void keyRepeated(int key)
    {
        keyPressed(key);
    }

    /**
      按键事件
     */
    protected void keyPressed(int key) {
        int action = getGameAction(key);
        int dir = 0;

        switch (action) {
        case RIGHT:   //改变颜色值
            dir += 1;
            break;

        case LEFT:
            dir -= 1;
            break;

        case UP:
            ndx -= 1;
            break;

        case DOWN:
            ndx += 1;
            break;

        default:
            return;
        }

        // ndx =0,1,2 表示蓝，绿，红三个颜色条件栏
        // 一个颜色 0xff ff ff，其第一个ff表示红，2表示绿，3表示蓝，
        // 通过 >> 方式获取对应颜色
        if (ndx < 0) {
            ndx = 0;
        }
        else
        if (ndx > 2) {
            ndx = 2;
        }
        else
        if (ndx >= 0) {
            //取出对于颜色值，改变
            int v = (rgbColor >> (ndx * 8)) & 0xff;
            v += (dir * 0x20);        //颜色呈8次递进变化。

            if (v < 0) {
                v = 0;
            }

            if (v > 255) {
                v = 255;
            }

            int mask = 0xff << (ndx * 8);
            //将改变的颜色值加到对应位。
            rgbColor = (rgbColor & ~mask) | (v << (ndx * 8));
        }

        //立即重画
        repaint();
    }
}

运行效果如下，

在学习中，看别人的代码细节不是很清楚，如果运行一下，就能理解代码是做什么了。
看来有时看代码，得动手多过几遍。

kenlistian 2008-06-23 21:36 发表评论

j2me 笔记5---ticker例子

kenlistian — Sun, 22 Jun 2008 04:00:00 GMT

继续学习j2me的ui编程，下面是实现ticker的例子，运行就是这样子：

/*
一个简单的提示现实类，在每个窗体中只允许有一个该类的实例。
如下的例子。
其代码如同以前加载工程中一样，运行它，测试界面如下：

*/

import javax.microedition.lcdui.*;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.midlet.MIDlet;

public class tickerdemo1 extends MIDlet implements CommandListener {

    private static final String TICKER_TEXT =
        "类似走马灯，又类似提示器。。。 " + "运行下看看。。。" ;

    private boolean firstTime;
    private Form mainForm;
    private Command exitCommand = new Command("Exit", Command.EXIT, 1);
    private Display myDisplay;
    private Ticker t;

    public tickerdemo1() {
        myDisplay = Display.getDisplay(this);
        firstTime = true;
        mainForm = new Form("新窗体");
        mainForm.setCommandListener(this);
    }

    protected void startApp() {
        if (firstTime) {
            t = new Ticker(TICKER_TEXT);   //创建实例
            mainForm.setTicker(t);
            firstTime = false;
        }

        mainForm.addCommand(exitCommand);
        myDisplay.setCurrent(mainForm);
    }

    protected void destroyApp(boolean unconditional) {
        myDisplay.setCurrent((Displayable)null);
        notifyDestroyed();
    }

    protected void pauseApp() {
    }

    public void commandAction(Command c, Displayable s) {
        if (c == exitCommand) {
            destroyApp(true);
        }
    }
}

kenlistian 2008-06-22 12:00 发表评论

j2me 笔记4--list例子

kenlistian — Sat, 21 Jun 2008 15:13:00 GMT

一个list 例子来看，demo 中的例子，

打开toolkid2.52中，创建listDemo工程文件，然后创建listDeom类，
把下面代码贴在src下面的新建立的listdemo.java文件名中，在toolkid
中build，run，可以看到实际运行结果。

说明下：
1.import 导入lcdui 类包。这是一个界面包。
2.Display 类，display 实例，通过setCurrent切换到当前界面。
3.commandAction函数，处理相应按钮事件。

************************************************************

import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;

public class ListDemo extends MIDlet implements CommandListener {

    private static final Command CMD_EXIT = new Command("退出", Command.EXIT, 1);
    private static final Command CMD_BACK = new Command("返回", Command.BACK, 1);

    private Display display;
    private List mainList;
    private List exclusiveList;
    private List implicitList;
    private List multipleList;
    private boolean firstTime;

    public ListDemo() {

        display = Display.getDisplay(this);

        String[] stringArray = { "Option A", "Option B", "Option C", "Option D" };
        Image[] imageArray = null;

        //创建单选list 界面，包括退出按钮和返回按钮及其事件
        exclusiveList = new List("单选", Choice.EXCLUSIVE, stringArray, imageArray);
        exclusiveList.addCommand(CMD_BACK);
        exclusiveList.addCommand(CMD_EXIT);
        exclusiveList.setCommandListener(this);

        //
        implicitList = new List("简单", Choice.IMPLICIT, stringArray, imageArray);
        implicitList.addCommand(CMD_BACK);
        implicitList.addCommand(CMD_EXIT);
        implicitList.setCommandListener(this);

        //多选list
        multipleList = new List("多选", Choice.MULTIPLE, stringArray, imageArray);
        multipleList.addCommand(CMD_BACK);
        multipleList.addCommand(CMD_EXIT);
        multipleList.setCommandListener(this);

        firstTime = true;
    }

    protected void startApp() {

        if (firstTime) {
            Image[] imageArray = null;

            try {
                // 加载icon,位置在res下相对目录
                Image icon = Image.createImage("/midp/uidemo/Icon.png");
                imageArray = new Image[] { icon, icon, icon };
            } catch (java.io.IOException err) {

            }

            String[] stringArray = { "单选", "简单", "多选" };

            //创建界面
            mainList = new List("Choose type", Choice.IMPLICIT, stringArray, imageArray);
            mainList.addCommand(CMD_EXIT);
            mainList.setCommandListener(this);

            //设置界面为当前为mainList
            display.setCurrent(mainList);
            firstTime = false;
        }
    }

    protected void destroyApp(boolean unconditional) {
    }

    protected void pauseApp() {
    }

    //处理按钮事件
    public void commandAction(Command c, Displayable d) {

        if (d.equals(mainList)) {  //当前界面为mainlist

            if (c == List.SELECT_COMMAND) { //
                if (d.equals(mainList)) {
                    //置换界面
                    switch (((List)d).getSelectedIndex())
                    {
                    case 0:
                        display.setCurrent(exclusiveList);
                        break;
                    case 1:
                        display.setCurrent(implicitList);
                        break;
                    case 2:
                        display.setCurrent(multipleList);
                        break;
                    }
                }
            }
        } else {
            //在子界面，按钮为CMD_BACK，返回主list界面
            if (c == CMD_BACK) {
                display.setCurrent(mainList);
            }
        }

        if (c == CMD_EXIT) {
            destroyApp(false);
            notifyDestroyed();
        }
    }
}

kenlistian 2008-06-21 23:13 发表评论

j2me 笔记3-----开发步骤

kenlistian — Thu, 19 Jun 2008 05:44:00 GMT

开发手机软件步骤
----------------

步骤

1 编写
2 编译
3 混淆 (可选)
4 预审核
5 打包   生产jar，同时需编写 jad后缀的描述文件。
6. 发布   将jar ，jad传输到手机。

再细致的描述如下：
-----------------------------------------------------------------------------------------------------
流程          工具                       输入                           输出
编译       javac.exe 编译           源文件(*.java)                   未混淆的类文件（*.class）
混淆       第三方提供的工具         未混淆的类文件(*.class)          混淆后的类文件(*.class)
预审       preverify.exe            预审核,混淆后的类文件(*.class)   经过预先审核的类文件(*.class)
打包       jar.exe                  经过预先审核的类文件(*.class)    包文件(*.jar)

编写
描述       文本编辑工具                                               描述文件（*.jad）
文件

安装       传输工具               包文件(*.jar),描述文件(*.jad)
        (IR/BT/数据线/OTA)

运行                                                                   在仿真器或手机上正式运行
-----------------------------------------------------------------------------------------------------

编译，混淆就不讲了。

混淆工具可以到如下下载：(不知道能不能下载得到)

JODE        http://jode.sourceforge.net/      开源
ProGuard    http://proguard.sourceforge.net/ 开源
RetroGuard http://www.retrologic.com/        开源，中国移动百宝箱强制使用
DashO       http://www.preemptive.com/        商业软件
ZKM         http://www.zelix.com/             商业软件
JBuilder     http://www.borland.com/          集成开发环境中内附混淆功能

预审核

   class 在传输过程中容易损坏或是被篡改，传统的Java 程序在运行前在本地机器上对.class
进行 Byte Code的审核。而对于手机这样的资源有限设备而言，在手机上进行此类的审核是浪费
资源的（如占用 CPU 的时间、消耗电力等）。故须先在PC 机上使用 preverify.exe进行一部
份预选审核工作。这样在手机上进行的审核工作就减少了。

打包也不需要赘叙。

安装
1 数据线，将 PC 与手机相连，下载文件 jar和jad
2 使用红外线
3 使用蓝牙
4 使用 OTA空中下载(利用短信/WAP)

kenlistian 2008-06-19 13:44 发表评论

j2me 笔记2

kenlistian — Wed, 18 Jun 2008 13:24:00 GMT

说百遍不如做一遍

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

WTK 的全称是Sun J2ME Wireless Toolkit —— Sun的无线开发工具包。

该工具箱包含了完整的生成工具、实用程序以及设备仿真器。

所了解的版本，以及对应可以开发的程序。

1.0.4 版只能够开发 MIDP1.0 应用程序。

2.0 版只能够开发 MIDP2.0 应用程序。

2.1 版则可开发 MIDP1.0、 JTWI(CLDC 1.0, MIDP2.0, WMA1.1)可改用 CLDC1.1或加入 MMAPI1.1)，

自定义(自己随机组合 Configuration, Profile以及 Optional Package)三种环境下的应用程序。

2.2 版， WTK全面的支持JTWI规范。即MIDP 2.0, CLDC 1.1, WMA 2.0, MMAPI 1.1,

Web Services (JSR 172), File and PIM APIs (JSR 75), Bluetooth and OBEX APIs (JSR 82), and

3D Graphics (JSR 184)；

也可用该版本开发面向 CLDC1.0 和 MIDP1.0 的应用程序。

现在都2.5了。估计支持以上。

sun 的官方网站下载链接：http://java.sun.com

安装完，有以下几个目录：

apps--- demo

bin --- 开发工具目录

docs ---help

lib --- 库文件

sessions --性能监控保存信息

wtklib----模拟器及其工具

j2mewtk_template ??

1.run toolkit

2.create 一个简单的程序。

3.new project

在创建工程文件名中命名工程名。如hello

4.设置平台架构

以最简单的MIDP1.0为架构。

点击ok，将在默认的目录中创建一个hello程序框架。

一般在本机的C:\Documents and Settings\Administrator\j2mewtk\2.5.2\apps\hello\

5.到该目录中的src中，创建和工程名同名的hello.java程序，粘贴下面的程序框架：

import javax.microedition.lcdui.*;

import javax.microedition.midlet.MIDlet;

public class hello extends MIDlet {

Display display;

public hello() {

super();

display = Display.getDisplay(this);

}

protected void startApp(){

Form form = new Form("Hello!");

form.append("welcome!");

display.setCurrent(form);

}

protected void pauseApp() {

}

protected void destroyApp(boolean arg0){

}

6.回到wtk，builder，然后run。将模拟器出来，即可看到

一个简单的程序出来了。

kenlistian 2008-06-18 21:24 发表评论

j2me 笔记一

kenlistian — Tue, 17 Jun 2008 11:40:00 GMT

j2me 笔记一

废话少说，自我的总结，标注笔记要纲。也算是自我学习j2me，做做笔记吧。

学习材料来自：http://www.j2medev.com/Article/Class1/Class11/200506/278.html

1.1 J2ME

J2ME是SUN公司针对嵌入式、消费类电子产品推出的开发平台，
与J2SE和J2EE共同组成Java技术的三个重要的分支。

J2ME实际上是一系列规范的集合，由JCP组织制定相关的Java Specification Request（JSR）并发布，
各个厂商会按照规范在自己的产品上进行实现，但是必须要通过TCK测试，这样确保兼容性。

1.2 J2ME平台体系结构

  J2ME平台由配置（Configuration）和简表（Profile）构成的。

  配置是提供给最大范围设备使用的最小类库集合，在配置中同时包含Java虚拟机。
  简表是针对一系列设备提供的开发包集合。

  可选包（Optional Package），它是针对特定设备提供的类库，

  如某些设备是支持蓝牙的，针对此功能J2ME中制定了JSR82（Bluetooth API）提供了对蓝牙的支持。

  J2ME中有两个最主要的配置，
  a.Connected Limited Devices Configuration（CLDC）
  b.Connected Devices Configuration（CDC）。

  CLDC主要针对那些资源非常受限的设备比如手机、PDA、双工寻呼机等。
  CDC主要面对那些家电产品，比如机顶盒、汽车导航系统等。

  简表是以配置为基础的，
  Mobile Information Devices Profile（MIDP）就是CLDC上层的重要简表。

1.3 MIDlet 程序模型
MIDP中定义了一种新的应用程序模型MIDlet。
被Application Management Software（AMS）管理的。

AMS负责MIDlet的安装、下载、运行和删除等操作。
MIDlet向AMS通信通知应用管理软件自己状态的变化，
MIDlet有三个状态，分别是pause、active和destroyed。

用一张图很好表达了状态转换。

MiDlet的程序模型框架如下：
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class HelloWorld extends MIDlet{

private Display display;

//构造函数
public HelloWorld(){

   display = Display.getDisplay(this);
   System.out.println("Constructor");

}

public void startApp(){

   System.out.println("startApp is called.");
   Form f = new Form("HelloTest");
   display.setCurrent(f);
}

public void pauseApp(){
   System.out.println("pauseApp is called.");
   }

public void destroyApp(boolean unconditional){
   System.out.println("destroyApp is called.");
   }

}

编译该程序后运行，控制台上输出：Constructor startApp is called.
退出该程序时，控制台就会输出： destroyApp is called.

kenlistian 2008-06-17 19:40 发表评论

备注二进制转换

kenlistian — Thu, 29 May 2008 02:12:00 GMT

public class unicodetest
{
　 public static void main(string args[])
　 {
　　　unicodetest　ut = new unicodetest();
　　　ut.test1();
　 }

　 public void test1()
{
　　　string str = "测试信息abc123";
　　　try
　{
　　　　 byte[] b = str.getbytes("gbk");
　　　　 system.out.println(str + " -(gbk)编码: " + bytestohexstr(b));
　　　　 system.out.println("");

　　　　 str = new string(b, "gbk");
　　　　 system.out.println("从gbk编码 "　+ bytestohexstr(b) + " 重新转换为字串: " + str);
　　　　 system.out.println("");

　　　　 b = str.getbytes("unicodebigunmarked");
　　　　 system.out.println(str + " -(ucs2)编码: " + bytestohexstr(b));
　　　　 system.out.println("");

　　　　 str = new string(b, "unicodebigunmarked");
　　　　 system.out.println("从(ucs2)编码 "　+ bytestohexstr(b) + " 重新转换为字串: " + str);
　　　　 system.out.println("");

　　　　 b = str.getbytes("ascii");
　　　　 system.out.println(str + " -(ascii)编码: " + bytestohexstr(b));
　　　　 system.out.println("");
　　　}
　　　catch(exception e){}
　 }

　 private string bytestohexstr(byte[] b)
　 {
　　　if (b == null) return "";
　　　stringbuffer strbuffer = new stringbuffer(b.length * 3);
　　　for(int i = 0; i < b.length; i++)
　{
　　　　 strbuffer.append(integer.tohexstring(b & 0xff));
　　　　 strbuffer.append(" ");
　　　}
　　　return strbuffer.tostring();
　 }
}

kenlistian 2008-05-29 10:12 发表评论