Main : Document List - Java ME & Capuchin

转 [J2ME] MMAPI的Cannot parse this type of AMR异常之讨论

developerworldwatch@kpi-consulting.net — Fri, 20 Nov 2009 11:46:19 GMT

转自旁观者 - 郑昀的博客 http://blog.csdn.net/zhengyun_ustc/archive/2006/04/17/666696.aspx

[J2ME] MMAPI的Cannot parse this type of AMR异常之讨论

郑昀草拟 20060417

[现象]

首先，我们假设遇到这种错误的人们了解如何使用MMAPI，从而排除代码使用不当问题。

那么在播放3gp媒体文件时遇到“java.lang.Exception: Cannot parse this type of AMR”的异常错误，如果怀疑是ffmpeg或者其他转换程序造成的话，那么你可以把Nokia手机自己拍摄的录像传到PC机上，这种文件格式就是3gp的，而且肯定是Nokia自己的手机程序能播放的。

但是，我用mmapi在Nokia S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）上播放这种Nokia手机生成的3gp文件时依然得到“java.lang.Exception: Cannot parse this type of AMR”错误，没有声音，只有视频。

我用下面的命令行：

Ffmpeg转换命令

ffmpeg -y -i test.mpeg -bitexact -vcodec h263 -b 128 -r 15 -s 176x144 -acodec aac -ac 2 -ar 22500 -ab 24 -f 3gp test.3gp

或者

ffmpeg -y -i test.mpeg -ac 1 -acodec amr_nb -ar 8000 -s 176x144 -b 128 -r 15 test.3gp

转换出来的3gp文件，都只能够在Nokia S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）上播放视频，但没有声音，也得到了大量的java.lang.Exception: Cannot parse this type of AMR错误提示。

我为什么要怀疑仅仅是S60模拟器的问题呢。因为我把转换好的3gp文件放在我的服务器上，用

简单的播放代码

player = Manager.createPlayer(url);

player.realize();

player.prefetch();

这种代码在Nokia7610真机上运行播放这个远端资源http://218.249.90.118/toodou/test.3gp ，结果正常地播放了，有声音，有图像！

所以说明Nokia 7610真机的MMAPI对于3gp文件中的音频解析是没问题的。出问题的是S60模拟器（Nokia Developer's Suite 3.0 for J2ME所携带的模拟器）

转 [J2ME]手机流媒体之实作[附源码][与RTSP/MMS协议无关]

developerworldwatch@kpi-consulting.net — Fri, 20 Nov 2009 11:42:52 GMT

转自旁观者 - 郑昀的博客http://blog.csdn.net/zhengyun_ustc/archive/2006/03/28/641991.aspx

[J2ME]手机流媒体之实作[附源码][与RTSP/MMS协议无关]

郑昀@ultrapower	产品名称	产品版本
Keyword: JavaME Streaming Audio MMAPI	StreamingDemo	1.0.13

[J2ME]现行环境下手机

实现网络媒体的流畅实时播放

之简单演示

(StreamingDemo)

说明

我的资源：

http://www.cnblogs.com/Files/zhengyun_ustc/StreamingDemo-src-1.0.13.rar

这个1.0.13版本是j2me流媒体播放思路的简单演示软件，并不是对现有的RTSP/MMS流媒体服务器的客户端实现，而是自定义算法下载来保证实时播放，可以在Nokia 7610手机上真实运行。在手机上使用，请在选择连接点时选择“移动梦网”连接点。

如果修改源代码中CommandResources.java中的m_bCMWAPProxy标志使之走CMNET通道，那么能够在Nokia S60的模拟器上运行。

本源代码的大致思路来自于我上次写的三篇讨论稿

J2me流媒体技术实现讨论[1]

J2me流媒体技术实现讨论[2]

J2me流媒体技术实现讨论[3] ，StreamingDemo的代码你可以借鉴，但不得用于商业用途，除非得到我的授权。

手机jar安装包下载：
http://www.cnblogs.com/Files/zhengyun_ustc/StreamingDemo-deployed.rar
可以将这个包中的StreamingDemo.jar传到您的手机上进行安装。
使用时，请选择移动梦网连接点。

如果你想使用劈分好的媒体文件，请从

http://www.cnblogs.com/Files/zhengyun_ustc/changjin.split.rar下载。

1背景、功能

摘要：本章简单描述StreamingDemo的背景、功能。

1.1. 手机上的流媒体

很多人都在j2medev.com上讨论过流媒体的实现方式。国外有一个人提出一种思路，并且号称在Nokia6260[相关数据：诺基亚 6260 Nokia62602.0 (3.0436.0) SymbianOS7.0s Series602.1 ProfileMIDP-2.0 ConfigurationCLDC-1.0]运行了。

当然我们这里说的不是对RTSP/MMS这种主流的流媒体服务器的客户端实现，因为现在中国市场的很多很多手机的Java环境都不支持这两个协议，只有新出的某些手机才内置支持这一功能。

我们这次讲的是，在现有GPRS环境下，在现有的一两千块钱的手机条件下，如何做到流媒体实时播放呢，而且还能做到较为流畅呢？

2006年1月份，我恰巧看到了

就此思路和诸位高手讨论了一下，并且写了三篇讨论稿，有了大致的思路。但一直都没有时间去测试这个思路是否可行。

今天索性抽出了一两个小时，把这个思路写出来放在真实手机/GPRS网络上测试，不敢独享，遂开放代码，希望借此抛砖引玉。

这里给出StreamingDemo的界面，很简单，主要的线程操作和消息处理都在后台：

1.2. 我所谓流媒体的功能

以前我们谈过：

第一步：
声明两个Player，分别由两个独立的线程掌控着；

第二步：
HttpConnection开始向服务器请求该audio文件的第一部分字节，我们定这次读取的字节数为18KB；

第三步：
等第一部分数据到位后，Player A开始realize和prefetch，并开始播放；

第四步：
在Player A播放同时，(18KB的amr数据可以播放10秒钟)，HttpConnection继续请求第二部分数据(假设GPRS每秒钟传输3KB，那么18KB需要传输6秒，算上前后通讯损失的时间，应该不会超过10秒钟)；

第五步：
第二部分数据到位后，假设Player A还没有播放完(这需要调整你的每一部份数据字节数来使得假设成立)，那么将数据喂给Player B让它realize和prefetch；

第六步：
Player A播放完后，得到事件通知，于是让Player B开始播放。

如此往复。

大致的思路就是这样。

这次，我们起了两个线程，一个叫做“Main(主) ”，一个叫做“Secondary(从属)”，他们都掌握着一个Player，同样一个是Main Player，一个是Secondary Player。这两个Player的操作实际上都被Audio.java类完全封装好了。线程里面仅仅是调用

Audio.prefetchSound(m_form,

m_isInputMusic,

m_Sequence);

啦，

Audio.playSound(m_Sequence);

啦，这样就可以把媒体资源预先运算以及播放了。

同时，还必须用到PlayerListener接口，来得到播放器的各种事件通知，我们需要得知每一个播放器的播放结束消息，以便作出下一步选择：是让从属线程开始播放呢，还是让主线程开始播放呢。

PlayerListener的播放结束消息(PlayerListener.END_OF_MEDIA)的处理中，我们还必须用到MVC模式中的Controller，它是代码中的GUIController.java，它负责处理几个消息：

l EventID.EVENT_MAIN_DownloadCompleted

l EventID.EVENT_Main_BeginToPlay

l EventID.EVENT_SECONDARY_BeginToPlay

怎么综合使用这些消息和事件呢？

比如说，当主线程的媒体文件下载完毕后，就应该通知GUIController让从属线程也开始下载并加载媒体文件。

当主线程的媒体文件播放完毕了，这时候照理说从属线程的Player也已经预先加载好了下一个要播放的媒体文件(如果不行的话就应该调整媒体文件的大小了以使得下载时间和播放时间差不多)，就应该在

public void playerUpdate(Player player, String event, Object data)

的函数处理中，让Secondary Player播放了。

这次我们直接将媒体文件用讨论稿中谈及的ffmpeg自动切分的办法，已经辟成11小段的AMR文件了，每一个AMR文件都可以独立播放，连起来就是一首完整的《大长今》乐曲。

PlayerA和PlayerB只是周而复始的下载、预运算、播放他们罢了。只不过掌控着Player的两个线程和主控制器，会选择时机来让这些操作次第展开。

上面所说的逻辑，可以用下图表示：

2 使用感受

摘要：本章简单描述StreamingDemo在真实GPRS环境下的使用感受。

2.1. Nokia7610手机上的设置

如果你真的要在手机上用到这种功能，那么请申请开通你的GPRS包月套餐，那样20块钱就可以使用50MB流量的GPRS了。

如果你的手机是Nokia的S60系列手机，建议用Nokia程序管理器设置这个应用配置一个参数：在连接网络时第一次询问。否则你会屡屡被网络连接警告框打断的。

2.2. Nokia7610手机上的使用感受

这种流媒体的播放，还是取决于使用时GPRS网络的好坏。

我在晚上19点使用了一下，感觉比较流畅，甚至超乎我的预期，不认真听，甚至感觉不到在哪里停顿的。

但是在晚上20点又用了一下，就有点拖拖拉拉的，延迟较为明显。

可见现行的GPRS网络环境还是容易出现拥挤的。

3 开源版权声明

由于这个手机流媒体简单演示的思路和代码来自于郑昀以前的讨论稿，今为了促进J2ME多媒体应用发展，决定遵照GPL协议的大意开放源代码，您可以自由传播和修改，在遵照下面的约束条件的前提下：

条件1

条件2

你可以修改 手机流媒体简单演示 程序的一个或几个副本或程序的任何部分，以此形成基于程序的作品。只要你同时满足下面的所有条件，你就可以按前面第一款的要求复制和发布这一经过修改的程序或作品。

a）

你必须在修改的文件中附有明确的说明：你修改了这一文件及具体的修改日期。

b）

你必须使你发布或出版的作品（它包含程序的全部或一部分，或包含由程序的全部或部分衍生的作品）允许第三方作为整体按许可证条款免费使用。

c）

这样，您就可以自由使用并传播本源代码，当然请您原封不动地保留创建者zhengyun_ustc(郑昀)的作者信息。

Java Verified 手册

developerworldwatch@kpi-consulting.net — Tue, 17 Nov 2009 09:30:37 GMT

本手册将逐步指导您实现，如何通过 Java Verified 提交门户网站提交应用软件进行认证，并简要介绍提交门户网站能为已提交的软件提供哪些服务。

它将带您通过认证流程涉及的所有步骤，包括从获取 Publisher ID 到最终在线提交应用软件进行测试与签名。

目录
1. 本手册的用途
2. 什么是 Java Verified 提交门户网站？
3. 什么是 Publisher ID？我该如何使用它？
4. 我该如何注册使用提交门户网站？
5. 在提交应用软件之前我需要做些什么？
6. 我该如何将应用软件提交到门户网站？
7. 我该如何提交应用软件进行研发签名？
8. 我该如何提交应用软件进行测试与签名？
9. 我该如何在门户网站上找到提交的内容？
附录 A: 签署多个 JAD / JAR 文件对的脚本示例
附录 B: 常见问题解答

关于如何在索尼爱立信手机上进行 Java 签名和 Java 的权限设置，请阅读下面的文章>>

索尼爱立信手机 Java ME 签名指南

索尼爱立信手机的 Java ME 的权限设置

http://www.javaverified.com

Java线程的同步

developerworldwatch@kpi-consulting.net — Wed, 11 Nov 2009 01:38:50 GMT

在J2ME开发中，线程是一个需要非常重视的问题，下面是一段关于线程的文章。我认为对打好线程基本很有帮助。

zz http://www.j2medev.com/Article/ShowArticle.asp?ArticleID=5478

一、同步问题提出

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。

public class Foo {
    private int x = 100;

    public int getX() {
        return x;
    }

    public int fix(int y) {
        x = x - y;
        return x;
    }
}

public class MyRunnable implements Runnable {
    private Foo foo = new Foo();

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread ta = new Thread(r, "Thread-A");
        Thread tb = new Thread(r, "Thread-B");
        ta.start();
        tb.start();
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX());
        }
    }

    public int fix(int y) {
        return foo.fix(y);
    }
}

运行结果：

Thread-A : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= -20
Thread-A : 当前foo对象的x值= -50
Thread-A : 当前foo对象的x值= -80
Thread-B : 当前foo对象的x值= -80

Process finished with exit code 0

从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。

如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。

在具体的Java代码中需要完成一下两个操作：

把竞争访问的资源类Foo变量x标识为private；

同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。

二、同步和锁定

1、锁的原理

Java中每个对象都有一个内置锁

当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。

当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。

一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

关于锁和同步，有一下几个要点：

1）、只能同步方法，而不能同步变量和类；

2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？

3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。

4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。

5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。

6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。

8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。

9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：

    public int fix(int y) {
        synchronized (this) {
            x = x - y;
        }
        return x;
    }

当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如：

    public synchronized int getX() {
        return x++;
    }

与

    public int getX() {
        synchronized (this) {
            return x;
        }
    }

效果是完全一样的。

三、静态方法同步

要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。

例如：

public static synchronized int setName(String name){

Xxx.name = name;

}

等价于
public static int setName(String name){
      synchronized(Xxx.class){
            Xxx.name = name;
      }
}

四、如果线程不能不能获得锁会怎么样

如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。

当考虑阻塞时，一定要注意哪个对象正被用于锁定：

1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。

2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。

3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。

4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。

五、何时需要同步

在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。

对于非静态字段中可更改的数据，通常使用非静态方法访问。

对于静态字段中可更改的数据，通常使用静态方法访问。

如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。已经超出SJCP考试范围了。

六、线程安全类

当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。

即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。

举个形象的例子，比如一个集合是线程安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作，也许在第一个线程查询后，第二个线程也查询出集合非空，但是当第一个执行清除后，第二个再执行删除显然是不对的，因为此时集合已经为空了。

看个代码：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public void add(String name) {
        nameList.add(name);
    }

    public String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        final NameList nl = new NameList();
        nl.add("aaa");
        class NameDropper extends Thread{
            public void run(){
                String name = nl.removeFirst();
                System.out.println(name);
            }
        }

        Thread t1 = new NameDropper();
        Thread t2 = new NameDropper();
        t1.start();
        t2.start();
    }
}

虽然集合对象

private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，但是程序还不是线程安全的。

出现这种事件的原因是，上例中一个线程操作列表过程中无法阻止另外一个线程对列表的其他操作。

解决上面问题的办法是，在操作集合对象的NameList上面做一个同步。改写后的代码如下：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public synchronized void add(String name) {
        nameList.add(name);
    }

    public synchronized String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

这样，当一个线程访问其中一个同步方法时，其他线程只有等待。

七、线程死锁

死锁对Java程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。

还是看一个比较直观的死锁例子：

public class DeadlockRisk {
    private static class Resource {
        public int value;
    }

    private Resource resourceA = new Resource();
    private Resource resourceB = new Resource();

    public int read() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                return resourceB.value + resourceA.value;
            }
        }
    }

    public void write(int a, int b) {
        synchronized (resourceB) {
            synchronized (resourceA) {
                resourceA.value = a;
                resourceB.value = b;
            }
        }
    }
}

假设read()方法由一个线程启动，write()方法由另外一个线程启动。读线程将拥有resourceA锁，写线程将拥有resourceB锁，两者都坚持等待的话就出现死锁。

实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU必须从读线程切换到写线程，所以，死锁基本上不能发生。

但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。已经超出SCJP的考试范围。

八、线程同步小结

1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。

2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。

3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

4、对于同步，要时刻清醒在哪个对象上同步，这是关键。

5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

JAVA/J2ME中文编码问题完全解决方案zz

developerworldwatch@kpi-consulting.net — Thu, 29 Oct 2009 02:57:12 GMT

zz http://mtiger2k.blog.51cto.com/90475/82801

最近开发了一个在手机上打谱的围棋软件，因为要读中文棋谱，所以需要支持中文编码。在诺基亚，索爱，多普达等机器上运行良好，可以打开中文棋谱，并显示正常的中文棋评。但在三星，MOTO，联想等机型上无法打开文件。无论用什么中文编码，包括GB2312，GB18030，GBK，都不行。我的做法是：

try {
     reader = new InputStreamReader(fis, "GB2312");
} catch (UnsupportedEncodingException ex) {
     showMsg("Unsupported Encoding Exception.");
     return;
}

后来决定自已处理GB2312字节。但是直接调用HGB2312.gb2utf8，诺基亚上没问题，在三星手机上还是行不通，显示乱码。

str = hgb2312.gb2utf8(str.getBytes());

研究了诺基亚SDK里的InputStreamReader实现后，发现Reader类无非就是按指定的编码，把字节一个一个提出来分析，按照编码格式拼装成一个个char，这个处理方式跟HGB2312里的字节处理原理是一样的。于是决定自己实现一个InputStreamReader。实际上只要继承java.io.Reader类，实现两个方法就行了：

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

public class InputStreamReader extends Reader {
private byte[] map = new byte[15228];
InputStream In;

public InputStreamReader(InputStream inputstream) throws Exception {
In = inputstream;
InputStream is = getClass().getResourceAsStream("/gb2u.dat");
is.read(map);
is.close();
}

public void close() throws IOException {
In.close();
}

public int read(char[] ac, int i, int j) throws IOException {
byte bt;
byte[] bytes;
int ret;
int k = 0;
while (k < j) {
   int c, h, l, ind;
   bytes = new byte[1];
   ret = In.read(bytes);
   if (ret==-1) break;

   bt = bytes[0];
   if (bt >= 0) {
             ac[i+k] = ((char) bt);
         } else {
          bytes = new byte[1];
          ret = In.read(bytes);
          if (ret==-1) break;

          h = 256 + bt;
             l = 256 + bytes[0];
             h = h - 0xA0 - 1;
             l = l - 0xA0 - 1;
             if (h < 9) {
                 ind = (h * 94 + l) << 1;
                 c = (byte2Int(map[ind]) << 8 | byte2Int(map[ind + 1]));
                 ac[i+k] = ((char) c);
             } else if (h >= 9 && h <= 14) {
              ac[i+k] = ((char) 0);
             } else if (h > 14) {
                 h -= 6;
                 ind = (h * 94 + l) << 1;
                 c = (byte2Int(map[ind]) << 8 | byte2Int(map[ind + 1]));
                 ac[i+k] = ((char) c);

             } else {
              ac[i+k] = ((char) 0);
             }
         }
   k++;
}
return k != 0 ? k : -1;
}

private int byte2Int(byte b) {
if (b < 0) {
return 256 + b;
} else {
return b;
}
}

}

其中主要是public int read(char[] ac, int i, int j) 这个方法。

这样直接用这个InputStreamReader包装InputStream类，其他代码根本不用改变。

测试结果：三星手机上可以打开中文棋谱了。其他手机型号如MOTO，联想，有待进一步确认。但我相信应该同样没问题。

数据文件gb2u.data请在http://download.csdn.net/source/263609获取

给游戏添加音乐zz

developerworldwatch@kpi-consulting.net — Thu, 29 Oct 2009 02:54:46 GMT

zz 转自www.j2mefans.com

J2me通过Mobile Media API 支持手机音频，这是在特定类型的设备上支持不同程度的多媒体的类和接口的一个集合。更具体地说，Mobile Media API划分为两个不同的API集合：
     一个是Mobile Media API,主要针对高级声音和多媒体能力；另一个是MIDP2.0 Media API，主要针对支持唯一音频的受限制的设备。很明显，我们主要是讨论后一部分。
     MIDP2.0 Media API 围绕着2个主要的部分进行设计：管理器，播放器，和控制器。MIDP2.0 Media API都位于javax.microedition.media 和javax.microedition.media.control包中。其中管理器Manager位于media包中，它通过为各种媒体类型创建播放器，从而使我们能够查询一个手机的媒体能力。播放器Player接口位于同一个包中，提供了一组通用的方法来控制音频的回放。控制器Control接口位于media.control包中，用来进行特定类型的媒体控制，例如，VolumeControl用来控制音量，ToneControl用来控制乐音。

如果要想知道我们的手机对语音支持的能力，我们可以使用下面的代码（只提供Canvas类）：
import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.media.control.*;

public class SCCanvas extends Canvas {
   private Display display;

   public SCCanvas(Display d) {
     super();
     display = d;
   }

void start() {
     display.setCurrent(this);
     repaint();
   }

public void paint(Graphics g) {
     // 清除画布
     g.setColor(0, 0, 0);
     g.fillRect(0, 0, getWidth(), getHeight());
     g.setColor(255, 255, 255);

    // 得到手机支持的声音的类型
     String[] contentTypes = Manager.getSupportedContentTypes(null);

    // 显示所支持的声音的类型
     int y = 0;
     for (int i = 0; i < contentTypes.length; i++) {
       // 显示类型
       g.drawString(contentTypes[i], 0, y, Graphics.TOP | Graphics.LEFT);
       y += Font.getDefaultFont().getHeight();

      // 如果支持乐音生成器，播放乐音
       if (contentTypes[i] == "audio/x-tone-seq") {
         try {

           Manager.playTone(ToneControl.C4, 2000, 100);
         }
         catch(MediaException me) {
         }
       }
     }
   }
}

下面是MIDP2.0手机所支持的常见的音频MIME类型：
audio/x-tone-seq 表示乐音和乐音序列；audio/x-wav表示声波声音；audio/midi表示midi音乐；audio/mpeg表示MP3音频。

使用MIDP2.0 Media API的步骤：
（1）    使用Manager类获得一个针对特定媒体类型的播放器。
（2）    使用Player接口在特定的播放器上播放媒体。
（3）    如果需要的话，使用Control接口来改变媒体的回放。

下面是一个播放乐音的例子：
byte tempo=50; // 设定声音播放速度
       byte d=8; // 音调值

      byte C4=ToneControl.C4; //基准音调
       byte D4=(byte)(C4+2); //音调值
       byte E4=(byte)(C4+4);
       byte G4=(byte)(C4+7);
       byte rest=ToneControl.SILENCE; //无声

      byte[] mySequence=
       {
         ToneControl.VERSION,1,             //设置版本号，当前必须设为1
         ToneControl.TEMPO,tempo,            //设置声音播放速度，值越大，播放越快
         ToneControl.SET_VOLUME,100,        //设置音量，值越大，音量越大
         ToneControl.BLOCK_START,0,        //预定义播放块，当前块号为0
         E4,d,D4,d,C4,d,E4,d,
         E4,d,E4,d,E4,d,rest,d,                //块的内容
         ToneControl.BLOCK_END,0,         //块定义结束符
         ToneControl.PLAY_BLOCK,0,         //播放当前块号为0的块，块号必须提前定义
         D4,d,D4,d,D4,d,rest,d,                //不使用块号方式播放的内容，必须位于块定义后面
       };

      //创建播放器
       Player p=Manager.createPlayer(Manager.TONE_DEVICE_LOCATOR);
       //准备播放信息
       p.realize();
       //获取音调控制
       ToneControl c=(ToneControl)p.getControl("ToneControl");
       //设置音调序列
c.setSequence(mySequence);
//设置播放资源，获取设备
       p.prefetch();
       //开始播放
       p.start();
     }
     catch(Exception e)
     {
     }

下面是一个播放音乐文件的例子：
try
{
       //从资源中获取声音
       InputStream is=getClass().getResourceAsStream("/"+"Testsound.mid");
       //创建播放MIDI声音的播放器
       Player player=Manager.createPlayer(is,"audio/midi");
       //获取播放信息
       player.realize();
       //获取设备
       player.prefetch();
       //开始播放声音
       player.start();

      VolumeControl control=(VolumeControl)player.getControl("VolumeControl"); //获得控制接口，此接口的获得必须在获取播放信息或者获取播放设备后面，如果在它们前面，将会出现无法播放声音的情况
       if(control!=null) //必须检查是否为null，因为有些声音格式可能不支持音量控制
       {
         control.setLevel(5); //设置音量级别为50
//control.setMute(true);                            //设置静音
       }

只是一个简单的例子，更详细的请参考专业的书籍。

用于MIDP的URLEncoder类（转）

developerworldwatch@kpi-consulting.net — Thu, 29 Oct 2009 01:37:59 GMT

转自http://blog.csdn.net/asklxf/archive/2005/10/20/509789.aspx

由于MIDP没有J2SE对应的java.net.URLEncoder类，因此，要向服务器发送HTTP请求，必须自己进行URL编码，参考JDK1.4.2的src代码，将其改为一个能用在MIDP环境中的URLEncoder类：

// URLEncoder.java
package com.mboker.blog.midp.http;

import java.io.*;

/**
* Encode url, just like java.net.URLEncoder.encode() in J2SE.<br>
* NOTE: This class is modified from java.net.URLEncoder class in J2SE 1.4.
*
* @author Xuefeng
*/
class URLEncoder {

private static final int MAX_BYTES_PER_CHAR = 10; // rather arbitrary limit, but safe for now

private static boolean[] dontNeedEncoding;
private static final int caseDiff = ('a' - 'A');

    static {
        dontNeedEncoding = new boolean[256];
        for (int i='a'; i<='z'; i++) {
            dontNeedEncoding[i] = true;
        }
        for (int i='A'; i<='Z'; i++) {
            dontNeedEncoding[i] = true;
        }
        for (int i='0'; i<='9'; i++) {
            dontNeedEncoding[i] = true;
        }
        dontNeedEncoding[' '] = true;
        dontNeedEncoding['-'] = true;
        dontNeedEncoding['_'] = true;
        dontNeedEncoding['.'] = true;
        dontNeedEncoding['*'] = true;
    }

private URLEncoder() {}

public static String encode(String s) {
boolean wroteUnencodedChar = false;

        StringBuffer out = new StringBuffer(s.length());
        ByteArrayOutputStream buf = new ByteArrayOutputStream(MAX_BYTES_PER_CHAR);
        OutputStreamWriter writer = new OutputStreamWriter(buf);

        for (int i = 0; i < s.length(); i++) {
            int c = (int) s.charAt(i);
            if (c<256 && dontNeedEncoding[c]) {
                out.append((char) (c==' ' ? '+' : c));
                wroteUnencodedChar = true;
            } else {
                // convert to external encoding before hex conversion
                try {
                    if (wroteUnencodedChar) { // Fix for 4407610
                        writer = new OutputStreamWriter(buf);
                        wroteUnencodedChar = false;
                    }
                    writer.write(c);
                    /*
                     * If this character represents the start of a Unicode
                     * surrogate pair, then pass in two characters. It's not
                     * clear what should be done if a bytes reserved in the
                     * surrogate pairs range occurs outside of a legal surrogate
                     * pair. For now, just treat it as if it were any other
                     * character.
                     */
                    if (c >= 0xD800 && c <= 0xDBFF) {
                        if ((i + 1) < s.length()) {
                            int d = (int) s.charAt(i + 1);
                            if (d >= 0xDC00 && d <= 0xDFFF) {
                                writer.write(d);
                                i++;
                            }
                        }
                    }
                    writer.flush();
                } catch (IOException e) {
                    buf.reset();
                    continue;
                }
                byte[] ba = buf.toByteArray();
                for (int j = 0; j < ba.length; j++) {
                    out.append('%');
                    char ch = toHex((ba[j] >> 4) & 0xF);
                    // converting to use uppercase letter as part of
                    // the hex value if ch is a letter.
                    if (isLetter(ch)) {
                        ch -= caseDiff;
                    }
                    out.append(ch);
                    ch = toHex(ba[j] & 0xF);
                    if (isLetter(ch)) {
                        ch -= caseDiff;
                    }
                    out.append(ch);
                }
                buf.reset();
            }
        }
        return out.toString();
    }

    private static char toHex(int digit) {
        if ((digit >= 16) || (digit < 0)) {
            return '\0';
        }
        if (digit < 10) {
            return (char)('0' + digit);
        }
        return (char)('a' - 10 + digit);
    }

    private static boolean isLetter(char c) {
        return (c>='a' && c<='z');
    }
}

J2SE的URLEncoder依赖于java.lang.Character的许多特性，将其全部剔除并改造为基本运算，即可在MIDP环境中使用，中文测试也一切正常。

J2ME 3D技术简介（转）

developerworldwatch@kpi-consulting.net — Thu, 29 Oct 2009 01:33:16 GMT

转自http://blog.csdn.net/asklxf/archive/2005/03/07/313208.aspx

3D技术对我们来说已经非常熟悉了，最常用的3D API有OpenGL和Microsoft的Direct 3D，在桌面游戏中早已广泛应用。对于J2ME程序而言，Mobile 3D Graphics API(JSR184)的出现，使得为手机应用程序添加3D功能成为可能。

JSR184标准（M3G：Mobile 3D Graphics）为Java移动应用程序定义了一个简洁的3D API接口，J2ME程序可以非常方便地使用M3G来实现3D应用比如游戏等等。M3G被设计为非常轻量级的，整个API的完整实现不超过150kb。

M3G是J2ME的一个可选包，以OpenGL为基础的精简版，一共有30个类，运行在CLDC1.1/CLDC2.0上（必须支持浮点运算），可以在MIDP1.0和MIDP2.0中使用。目前，支持M3G的手机有Nokia 6230/3650/7650/6600、Siemens S65/CX65/S55/M55、Sony-Ericsson K700i/P800/P900、Moto 220/T720等。M3G只是一个Java接口，具体的底层3D引擎一般由C代码实现，比如许多手机厂商的3D引擎采用的便是SuperScape公司的Swerve引擎，这是一个专门为移动设备设计的高性能3D引擎。

类似于Microsoft的D3D，M3G支持两种3D模式：立即模式（immediate mode）和保留模式（retained mode）。在立即模式下，开发者必须手动渲染每一帧，从而获得较快的速度，但代码较繁琐；在保留模式下，开发者只需设置好关键帧，剩下的动画由M3G完成，代码较简单，但速度较慢。M3G也允许混合使用这两种模式。

3D模型可以在程序中创建，但是非常繁琐。因此，M3G提供一个Loader类，允许直接从一个单一的.m3g文件中读入全部3D场景。m3g文件可以通过3D Studio Max之类的软件创建。

如果熟悉OpenGL，那么M3G是非常容易理解的。在M3G中，Graphics3D是3D渲染的屏幕接口，World代表整个3D场景，包括Camera（用于设置观察者视角）、Light（灯光）、Background（背景）和树型结构的任意数量的3D物体。3D对象在计算机中用点（Point, Pixel）、线（Line, Polyline, Spline）、面（Mesh）来描述，具体存储和运算（如旋转、投影）都是矩阵运算和变换。

SUN的WTK2.2已经内置了M3G的实现包，如果安装了WTK2.2，就可以在模拟器上运行3D MIDP程序。可以参考WTK2.2的示例demo3d。

下面是一个最简单的M3G程序，来自Sony-Ericsson的示例代码，它创建一个旋转的金字塔，可以从此处下载完整代码并在WTK2.2中运行。

首先，我们要获得唯一的Graphics3D实例，用于渲染3D场景。Graphics3D是一个Singleton实现，可以在任何地方获得：

g3d = Graphics3D.getInstance();

然后，在Canvas中渲染：

public class MyCanvas extends Canvas
{
   public void paint(Graphics g) {
   try {
      g3d.bindTarget(g);
      ... update the scene ...
      ... render the scene ...
   } finally {
      g3d.releaseTarget();
   }
}

接下来创建一个World并设置Camera：

world = new World();
camera = new Camera();
world.addChild(camera);
// The width and height of the canvas.
float w = getWidth();
float h = getHeight();
// Constructs a perspective projection matrix and sets that as the current projection matrix.
camera.setPerspective(60.0f, w / h, 0.1f, 50f);
world.setActiveCamera(camera);

接着，在createPyramid()方法中创建一个Mesh，代表金字塔，并添加到World中：

private Mesh pyramidMesh; // the pyramid in the scene

pyramidMesh = createPyramid(); // create our pyramid.
pyramidMesh.setTranslation(0.0f, 0.0f, -3.0f); // move the pyramid 3 units into the screen.
world.addChild(pyramidMesh); // add the pyramid to the world

最后，在一个线程中让金字塔绕Y轴旋转起来：

public void run() {
    Graphics g = getGraphics();
    while(true) {
        // rotate the pyramid 1 degree around the Y-axis.
        pyramidMesh.postRotate(3.0f, 0.0f, 1.0f, 0.0f);
        draw3D(g);
        flushGraphics();
    }
}

以上对M3G作了一个简单的介绍，如果需要更多资料，可以参考：

http://jcp.org/en/jsr/detail?id=184
http://www.opengl.org

点击下载源代码

Capuchin-JavaME程序员开发延伸之路.

developerworldwatch@kpi-consulting.net — Fri, 08 May 2009 16:08:54 GMT

低级UI上实现九宫图

developerworldwatch@kpi-consulting.net — Wed, 21 Oct 2009 02:41:30 GMT

由于J2ME并没有提供Button控件，更不用说ImageButton了。所以J2ME中要实现九宫图只能通过Canvas和KeyPressed。

自己有个原创的，可以自适应屏幕大小。但很抱歉不能发布出来（软件所有权不属于我，555~~）。虽然这个实现很简单，但是却很繁琐，而且最近太懒了，不想单独再提炼一份。所以转一个过来。

转自：http://www.javaeye.com/topic/491888，如有转载，请注明出处。

核心代码如下：
public static final String[] filenames = { "/01.png", "/02.png", "/03.png",
   "/04.png", "/05.png", "/06.png" };
public static final String[] labels = { "公文推送", "通知公告", "日程安排", "通讯录查询",
   "会议室查询", "手机邮箱" };
public Image[] icons = new Image[9];
public void paint(Graphics g) {
int cw = this.getWidth();
int ch = this.getHeight();
try {
   // paintHead(g);
   this.setFullScreenMode(true);
   Image img = Image.createImage("/sliderbgn.JPG");
   // g.drawImage(img,0, 0, Graphics.TOP|Graphics.LEFT);
   g.drawImage(img, 0, 0, Graphics.TOP
     | Graphics.LEFT);

   for (int i = 0; i < filenames.length; i++) {
    try {
     icons[i] = Image.createImage(filenames[i]);
    } catch (IOException ex) {

    }
   }
   int old_color = g.getColor();
   g.setColor(0xffffff);
      int startY=ch/4;

   for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {

     g.drawImage(icons[i * 3 + j], j * cw / 3 + 10, startY+i * ch*3 / 10,
       Graphics.TOP | Graphics.LEFT);
     g.drawString(labels[i * 3 + j], j * cw / 3 + 30, startY+i * ch*3 / 10
        + icons[i].getHeight(),
       Graphics.HCENTER | Graphics.TOP);


    }
   }
   g.setColor(old_color);
   paintBottom(g);
} catch (Exception ex) {
   System.out.println(ex.toString());
}
}

在J2ME中查找内存泄漏的方法

developerworldwatch@kpi-consulting.net — Tue, 20 Oct 2009 15:07:01 GMT

转自http://www.loongzh.com/?p=69

在J2ME中查找内存泄漏是一件很困难的事，它不像J2SE似的有很强大的工具支持，但是它还是有一定的方法来做的。

首先在查找内存泄漏时，不要使用Runtime.free/totalMemory()这两个函数，它们在大多数情况下得到的数值都是不准确的，也不要相信WTK中的memory monitor显示的数值,它也是不准确的。如果说有什么模拟器的可以相信的话，Nokia的S40手机的模拟器可能算上一个。可遗憾的是它比较不好用。

既然通过得到内存大小的方式是不保险的，那么在碰到内存泄漏的情况下要怎么来判断了？答案是使用WTK 的memory monitor，WTK的memory monitor显示的内存不正确，但是它还有一个功能是显示每一个class的instance个数，通过比较memory monitor的instance与实际中需要的instance个数，我们就能得出是否发生内存泄漏，泄漏在那几个对象上。

当确定内存泄漏的地方后，可以通过排除法来锁定内存泄漏的代码：把功能一点点的去掉，看内存泄漏现像是否存在，如果不存在，那么就找到对应的代码了。当然这还存在一个问题，那就是当功能去掉时，可能会导致泄漏的内存大小也变小，如果以为这就是找到对应的代码的话，那么就大错特错了，因为内存的减少可能是资源图片的减少了（资源图片占用的内存都比较大，少加张图片和不少加图片是相差很大的）。为了避免这种情况，还是要用到memory monitor，使用它来比较instancer的个数，通过instance的个数是否减少来判断是否在是真正找到对应的问题所在。

使用这种方法是痛苦的，除了这种方法，还有一种就是看代码，这里说的看代码是有几个侧重点的，不是什么代码都要仔仔细细的看一遍过去的！首先可以看一下Vector这种变量，看是否出现像《Effective Java》中第六条的情况，出现过期引用的情况。这种情况是相当常见的（都上了《Effect Java》，肯定常见了），然后可以看一下Listener（监听器）与回调的实现。在Listener中，很有可能的情况就是对象A指向对B，A做为listener注册到一个hashtable中去了。这时把B的值设置为null，而不清除对应的listener的话，那么B这个对象也是不会被回收的。

总得说来，在查找内存泄漏的时候，我们不要相信J2ME的函数，善用工具，有侧重的查看代码。做到这些，问题肯定会被解决的。