鲜为人知的Titanium之单例

Titanium能够用JS的方式来实现APP的编码，这确实是够强大，但是，在module与app之间的交互，即通过调用与回调的方式之中，不同的方法能够让module的身份变得不同。
1、##一般模式 ##

    private KrollFunction successCallback = null;
    private KrollFunction errorCallback = null;
    // method to invoke success callback
private void sendSuccessEvent(String filepath) {
    if (successCallback != null) {
        HashMap event = new HashMap();
        event.put("filePath", filepath);
        event.put("fileName", outPutFileName);

        // Fire an event directly to the specified listener (callback)
        successCallback.call(getKrollObject(), event);
    }
}

// method to invoke error callback
private void sendErrorEvent(String message) {
    if (errorCallback != null) {
        HashMap event = new HashMap();
        event.put("message", message);

        // Fire an event directly to the specified listener (callback)
        errorCallback.call(getKrollObject(), event);
    }
}

// method to register callbacks, which all passed from javascript layer
@Kroll.method
public void registerCallbacks(HashMap args) {
    Object callback;

    // Save the callback functions, verifying that they are of the correct
    // type
    if (args.containsKey("success")) {
        callback = args.get("success");
        if (callback instanceof KrollFunction) {
            successCallback = (KrollFunction) callback;
        }
    }

    if (args.containsKey("error")) {
        callback = args.get("error");
        if (callback instanceof KrollFunction) {
            errorCallback = (KrollFunction) callback;
        }
    }
}
@Kroll.method
public void startRecording(HashMap args) {
        // this method used to register success and error callbacks
        registerCallbacks(args);
}

该方法是从下面的链接中学到的，这也是我们一般的做法

http://www.titaniumtutorial.com/2013/10/android-module-development-part-2_9.html
在JS中，我们只要这样做就可以监听回调

var module= require("titutorial.audiorecorder");

module.startRecording({
    success: function (e) {
        alert("success => " + e.filePath);
    },
    error: function (d) {
        alert("error => " + e.message);
    }
});

2、##单例模式##
如果我们抛弃上面的那第一种方法，改为

    HashMap map = new HashMap();
    map.put("content", "内容");
    fireEvent("Callback",map);

这样，让module的身份变成单例，因为，在JS中，要这样来接收回调

var module= require("titutorial.audiorecorder");
module.addEventListener('Callback',function(e){
var content = e.content;
Titanium.API.info('这里接收回调 content = '+content);
}

module一旦定义了，就会一直存在，重新new一个的话，旧的module 也会一直存在，回调也会跟着接收，导致本来需要时一个回调，变成每new一个module的时候，回调也跟着增加了。所以，在JS中需要这样

module.removeEventListener('Callback',function(e){
    .......
}

这样做的好处是，代码能更加简洁，调用跟回调可以区分开。
以上。