readwritemidlet.java

利用SyncML开发客户端程序的中间件

/*
 * Copyright (C) 2003-2007 Funambol
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */

package com.funambol.storage;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.RecordStoreException;

public class ReadWriteMidlet extends MIDlet implements CommandListener {
    
    public static final String STORENAME = "DummyStore";
    
    /** 
     * Creates a new instance of ReadWriteMIDlet 
     */
    public ReadWriteMidlet() {
        initialize();
    }
    
    private Form mainForm;
    private Command writeRecord;
    private Command readRecords;
    private Command exitMidletCommand;
    private Form readForm;
    private Command backFromReadCommand;
    private ObjectStore objs;
    private TestClass storedClass; 
    private TestContainer storedContainer; 
    
    /** 
     * This method initializes the application.
     */
    private void initialize() {
        storedClass = new TestClass("storedHt");
        storedContainer = new TestContainer(storedClass);
        objs = new ObjectStore();
        try {
            objs.create(STORENAME);
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        getDisplay().setCurrent(get_mainForm());
    }
    
    /**
     * @return Dispaly an instance of the display.
     */
    public Display getDisplay() {                         
        return Display.getDisplay(this);
    }                        
    
    /** 
     * @return Instance for mainForm component
     */
    public Form get_mainForm() {
        if (mainForm == null) {
            
            mainForm = new Form("Main Form", new Item[0]);
            mainForm.addCommand(get_readRecords());
            mainForm.addCommand(get_writeRecord());
            mainForm.addCommand(get_exitMidletCommand());
            mainForm.setCommandListener(this);
        
        }
        return mainForm;
    }

    /** 
     * @return Instance for writeRecord component
     */
    public Command get_writeRecord() {
        if (writeRecord == null) {
            
            writeRecord = new Command("write", Command.OK, 1);
        
        }
        return writeRecord;
    }

    /** 
     * @return Instance for readRecords component
     */
    public Command get_readRecords() {
        if (readRecords == null) {
        
            readRecords = new Command("read", Command.OK, 2);
        
        }
        return readRecords;
    }

    /**
     * @return Instance for exitMidletCommand component
     */
    public Command get_exitMidletCommand() {
        if (exitMidletCommand == null) {
            exitMidletCommand = new Command("Back", Command.EXIT, 1);
        }
        return exitMidletCommand;
    }

    /** 
     * @return Instance for readForm component
     */
    public Form get_readForm() {
        if (readForm == null) {
            readForm = new Form("Written Records", new Item[0]);
            readForm.addCommand(get_backFromReadCommand());
            readForm.setCommandListener(this);
        }
        return readForm;
    }

    /**
     * @return Instance for backFromReadCommand component
     */
    public Command get_backFromReadCommand() {
        if (backFromReadCommand == null) {
        
            backFromReadCommand = new Command("Back", Command.BACK, 1);
        
        }
        return backFromReadCommand;
    }
    
    /** 
     * Command Flow State Machine:
     * @param command the Command that was invoked
     * @param displayable the Displayable on which the command was invoked
     */
    public void commandAction(Command command, Displayable displayable) {
        if (displayable == mainForm) {
            if (command == exitMidletCommand) {
                
                exitMIDlet();
            
            } else if (command == writeRecord) {
                writeObjsRecord(objs);
                exitMIDlet();
            
            } else if (command == readRecords) {
                
                getDisplay().setCurrent(get_readForm());
                readObjsRecord(objs);
            }
        } else if (displayable == readForm) {
            if (command == backFromReadCommand) {
                
                getDisplay().setCurrent(get_mainForm());
            
            }
        }
    }
    
    /**
     * Exit the midlet.
     */
    public void exitMIDlet() {                         
        getDisplay().setCurrent(null);
        destroyApp(true);
        notifyDestroyed();
    }                        
    
    /**
     * Writes some record to the given recordstore
     * @param objs is the ObjectStore on which records will be written
     */
    private void writeObjsRecord(ObjectStore objs) {
        try {
            objs.open(STORENAME);
            objs.store(storedClass);
            objs.store(storedContainer);
            objs.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
    }
    
    /**
     * Writes some record to the given recordstore
     * @param objs is the ObjectStore on which records will be written
     */
    private void readObjsRecord(ObjectStore objs) {
        TestClass actualStoredClass = null;
        TestContainer actualStoredContainer = null;
        try {
            objs.open(STORENAME);
            actualStoredClass = (TestClass) objs.retrieve(1, new TestClass());
            actualStoredContainer = (TestContainer) objs.retrieve(2, new TestContainer());
            objs.close();
            readForm.append(actualStoredClass.toString());
            readForm.append(actualStoredContainer.toString());
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
    }
        
    public void startApp() {
    }
    
    public void pauseApp() {
    }
    
    public void destroyApp(boolean unconditional) {
    }
}