J2ME learning - RMS from entry to proficiency one

Record Management System is an important subsystem of J2ME, which aims to achieve persistent storage of local data in applications. Currently, mobile information devices that support file systems are limited, so Record Management System is the preferred way for J2ME developers to implement local data storage. The purpose of this article is to comprehensively introduce Record Management System knowledge.

　 As the name suggests, Record Management System is a system for managing data, and Record is the most important entity in the system. What is stored in the mobile device storage space is not a field, but a byte array. The Mobile Information Device PROfile (MIDP) specification does not stipulate what kind of data can be stored as a record. In fact, a record is any data that can be represented by a byte array, such as pictures, text, etc. Record Management The responsibility of the System is to store and uniquely identify records, while the task of representing data is completed by the application. Therefore, J2ME developers often have to spend more energy processing the data in the storage space. The purpose of this is to simplify the implementation of MIDP and make the J2ME subsystem as small and flexible as possible. After all, mobile information devices have limited storage space and processor capabilities.

　Record Store is an ordered collection of a series of records. Records cannot exist alone and must belong to the Record Store. Record Store ensures that the read and write operations of records are atomic and the data will not be destroyed. In the API, Record Store is implemented by javax.microedition.rms.RecordStore. The specific operations of RecordStore will be introduced in detail in the following article.

　The MIDP specification states that mobile information devices must provide at least 8K of non-volatile storage space for applications to achieve persistent storage of data. But the space provided by different devices is not the same. If MIDlet The suite uses Record Management System, then it must specify the minimum data storage space it requires by setting MIDlet-Data-Size in the MANIFEST file and JAD file, in bytes, for example, MIDlet-Data-Size: 8192. If your value exceeds the maximum specified by the mobile device then your application will not install correctly. This value is not the maximum Record that the mobile device actually provides to the application. Management System storage space is often larger, so developers should avoid setting the minimum storage space required by applications too large and refer to the instruction manual of the relevant device when necessary. Reading and writing data in non-volatile storage space is often slow, so it is best to provide a caching mechanism to improve performance for frequently accessed data. Record The read and write operations of the Management System are thread-safe, but because the Record Store is controlled by the entire MIDlet Suite is shared, so if threads running on different MIDlets operate the Record Store, we should perform necessary thread synchronization to avoid data damage.

　About Record in MIDP1.0 and MIDP2.0 The implementation of Management System is somewhat different. MIDlets in the same MIDlet suite can access each other's Records. Store. However, in the implementation of MIDP1.0, there is no provision for sharing Records between different MIDlet suites. Store mechanism. A new API is provided in MIDP2.0 to solve the problem of sharing Records between different MIDlet suites. Regarding Store issues, when creating a Record Store, the sharing mechanism is managed through the authorization mode and read-write control parameters. I will introduce it in detail in the next article.

　Strengthen the Record Management The best way to understand System is to carry out actual development. During the development, I found that not all MIDP implementations of mobile devices are accurate. When I use the getSizeAvaliable() method to query the available records of Nokia6108 The value I got when using the Store space was more than 1M bytes, but when I wrote 40K of data, a RecordStoreFullException exception occurred, so I wrote an automatic test phone Record Store the software with the largest storage space. The principle is to send data to Record every certain time, such as 100-500 milliseconds. Write 1K bytes of data into the Store. When an exception that the storage space is full is thrown, the maximum value can be obtained. The precise unit is K bytes. The following is the source code of the program and the contents of the JAD file. The development platform is Eclipse3.0RC2+EclipseME0.4.1+Wtk2.1+J2SDK1.4.2._03. The test passed on the real Nokia 6108 and showed that the maximum value is 31K. (Please do not test on the simulator, as the results will be meaningless)

　 Summary: This article only leads readers to the Record Management System has a general understanding, although an application is provided at the end of the article. But there is no in-depth analysis of how to use Record Management System. In the next article, we will analyze the classes in the javax.microedition.rms package in depth, focusing on how to use the RecordStore class.

　　import javax.microedition.lcdui.Alert;

　import javax.microedition.lcdui.AlertType;

　　import javax.microedition.lcdui.Display;

　　import javax.microedition.midlet.MIDlet;

　import javax.microedition .midlet.MIDletStateChangeException;

　import javax.microedition.rms.RecordStoreException;

　　public class RMSAnalyzer extends MIDlet

　　{

　　private Display display;

　　private CounterCanvas counterCanvas;

　　private Alert alert;

　　protected void startApp() throws MIDletStateChangeException

　　{

　　display = Display.getDisplay(RMSAnalyzer.this);

　　alert = new Alert("错误提示");

　　try

　　{

　　String interval = this.getAppProperty("INTER");

　　int t = Integer.parseInt(interval);

　　counterCanvas = new CounterCanvas(t, 1, this);

　　}

　　catch (RecordStoreException e)

　　{

　　this.showAlertError(e.getMessage());

　　}

　　display.setCurrent(counterCanvas);

　　}

　　public Display getDisplay()

　　{

　　return display;

　　}

　　protected void pauseApp()

　　{

　　}

　　protected void destroyApp(boolean arg0) throws MIDletStateChangeException

　　{

　　}

　　public void showAlertError(String message)

　　{

　　alert.setString(message);

　　alert.setType(AlertType.ERROR);

　　alert.setTimeout(3000);

　　display.setCurrent(alert);

　　}

　　}

　　import java.util.Timer;

　　import java.util.TimerTask;

　　import javax.microedition.lcdui.Canvas;

　　import javax.microedition.lcdui.Command;

　　import javax.microedition.lcdui.CommandListener;

　　import javax.microedition.lcdui.Displayable;

　　import javax.microedition.lcdui.Graphics;

　　import javax.microedition.midlet.MIDletStateChangeException;

　　import javax.microedition.rms.*;

　　public class CounterCanvas extends Canvas implements CommandListener

　　{

　　private RMSModel model;

　　private RMSAnalyzer RMSanalyzer;

　　private int interTime;

　　private int counter;

　　private boolean go = true;

　　public static Command backCommand = new Command("退出", Command.EXIT, 3);

　　public static final int INC = 1;

　　public final Timer timer = new Timer();

　　public CounterCanvas(int interTime, int base, RMSAnalyzer rmsa)

　　throws RecordStoreException

　　{

　　this.interTime = interTime;

　　this.counter = base;

　　this.RMSanalyzer = rmsa;

　　model = new RMSModel(base, RMSanalyzer);

　　this.addCommand(backCommand);

　　this.setCommandListener(this);

　　TimerTask timerTask = new TimerTask()

　　{

　　public void run()

　　{

　　try

　　{

　　model.writeRecord(INC);

　　counter++;

　　} catch (RecordStoreFullException e)

　　{

　　go = false;

　　model.deleteRMS();

　　timer.cancel();

　　} catch (RecordStoreException e)

　　{

　　model.deleteRMS();

　　RMSanalyzer.showAlertError(e.getMessage());

　　timer.cancel();

　　}

　　repaint();

　　}

　　};

　　timer.schedule(timerTask, 1000, interTime);

　　}

　　public void setCounter(int counter)

　　{

　　this.counter = counter;

　　}

　　public void setInterTime(int interTime)

　　{

　　this.interTime = interTime;

　　}

　　protected void paint(Graphics arg0)

　　{

　　int SCREEN_WIDTH = this.getWidth();

　　int SCREEN_HEIGHT = this.getHeight();

　　arg0.drawRect(SCREEN_WIDTH / 10, SCREEN_HEIGHT / 2,

　　SCREEN_WIDTH * 4 / 5, 10);

　　if(RMSanalyzer.getDisplay().isColor())

　　{

　　arg0.setColor(128, 128, 255);

　　}

　　arg0.fillRect(SCREEN_WIDTH / 10, SCREEN_HEIGHT / 2, counter, 10);

if (!go)

The above is the content of J2ME learning - RMS from entry to master. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!