Examples of javax.microedition.rms.RecordStore

javax.microedition.rms.RecordStore
A class representing a record store. A record store consists of a collection of records which will remain persistent across multiple invocations of the MIDlet. The platform is responsible for making its best effort to maintain the integrity of the MIDlet's record stores throughout the normal use of the platform, including reboots, battery changes, etc.
Record stores are created in platform-dependent locations, which are not exposed to the MIDlets. The naming space for record stores is controlled at the MIDlet suite granularity. MIDlets within a MIDlet suite are allowed to create multiple record stores, as long as they are each given different names. When a MIDlet suite is removed from a platform all the record stores associated with its MIDlets will also be removed. MIDlets within a MIDlet suite can access each other's record stores directly. New APIs in MIDP allow for the explicit sharing of record stores if the MIDlet creating the RecordStore chooses to give such permission.

Sharing is accomplished through the ability to name a RecordStore created by another MIDlet suite.

RecordStores are uniquely named using the unique name of the MIDlet suite plus the name of the RecordStore. MIDlet suites are identified by the MIDlet-Vendor and MIDlet-Name attributes from the application descriptor.

Access controls are defined when RecordStores to be shared are created. Access controls are enforced when RecordStores are opened. The access modes allow private use or shareable with any other MIDlet suite.

Record store names are case sensitive and may consist of any combination of between one and 32 Unicode characters inclusive. Record store names must be unique within the scope of a given MIDlet suite. In other words, MIDlets within a MIDlet suite are not allowed to create more than one record store with the same name, however a MIDlet in one MIDlet suite is allowed to have a record store with the same name as a MIDlet in another MIDlet suite. In that case, the record stores are still distinct and separate.

No locking operations are provided in this API. Record store implementations ensure that all individual record store operations are atomic, synchronous, and serialized, so no corruption will occur with multiple accesses. However, if a MIDlet uses multiple threads to access a record store, it is the MIDlet's responsibility to coordinate this access or unintended consequences may result. Similarly, if a platform performs transparent synchronization of a record store, it is the platform's responsibility to enforce exclusive access to the record store between the MIDlet and synchronization engine.

Records are uniquely identified within a given record store by their recordId, which is an integer value. This recordId is used as the primary key for the records. The first record created in a record store will have recordId equal to one (1). Each subsequent record added to a RecordStore will be assigned a recordId one greater than the record added before it. That is, if two records are added to a record store, and the first has a recordId of 'n', the next will have a recordId of 'n + 1'. MIDlets can create other sequences of the records in the RecordStore by using the RecordEnumeration class.

This record store uses long integers for time/date stamps, in the format used by System.currentTimeMillis(). The record store is time stamped with the last time it was modified. The record store also maintains a version number, which is an integer that is incremented for each operation that modifies the contents of the RecordStore. These are useful for synchronization engines as well as other things.
@since MIDP 1.0

    }


    public synchronized void load()
            throws DBException
    {
        RecordStore rs = null;
        try
        {
            try
            {
                rs = RecordStore.openRecordStore( RS_NAME, false );
                final ByteArrayInputStream bais = new ByteArrayInputStream(
                        rs.getRecord( 1 )
                );
                final SerializerInputStream in = new SerializerInputStream(
                        bais
                );
                deserialize( in );
            }
            catch( RecordStoreNotFoundException e )
            {
            }
        }
        catch( RecordStoreException e )
        {
            throw new DBException( Constants.ERR_LIF_LOAD, e );
        }
        catch( SerializationException e )
        {
            throw new DBException( Constants.ERR_LIF_LOAD, e );
        }
        finally
        {
            if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
        }
    }

View Full Code Here

    }


    public synchronized void save()
            throws DBException
    {
        RecordStore rs = null;
        try
        {
            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
            final SerializerOutputStream out = new SerializerOutputStream( baos );
            serialize( out );
            final byte[] data = baos.toByteArray();
            rs = RecordStore.openRecordStore( RS_NAME, true );
            if( rs.getNumRecords() == 0 )
            {
                rs.addRecord( data, 0, data.length );
            }
            else
            {
                rs.setRecord( 1, data, 0, data.length );
            }
        }
        catch( RecordStoreException e )
        {
            throw new DBException( Constants.ERR_LIF_SAVE, e );
        }
        catch( SerializationException e )
        {
            throw new DBException( Constants.ERR_LIF_SAVE, e );
        }
        finally
        {
            if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
        }
    }

View Full Code Here

        }
    }


    static synchronized void load()
    {
        RecordStore rs = null;
        RecordEnumeration re = null;
        //noinspection CheckForOutOfMemoryOnLargeArrayAllocation
        byte[] buffer = new byte[ 256 ];
        try
        {
            rs = RecordStore.openRecordStore( RS_NAME, true );
            cache = new Hashtable( rs.getNumRecords() );
            re = rs.enumerateRecords( null, null, false );
            int recordId;
            int recordSize;
            //noinspection MethodCallInLoopCondition
            while( re.hasNextElement() )
            {
                recordId = re.nextRecordId();
                recordSize = rs.getRecordSize( recordId );
                if( buffer.length < recordSize )
                {
                    buffer = new byte[ recordSize + 64 ];
                }
                rs.getRecord( recordId, buffer, 0 );
                final StoreInfo info = new StoreInfo();
                info.deserialize( new SerializerInputStream(
                        new ByteArrayInputStream( buffer )
                ) );
                info.recordId = new Integer( recordId );
                cache.put( info.name, info );
            }
        }
        catch( RecordStoreException e )
        {
            log.error( e );
            ErrorHandler.handleError( null, e );
        }
        catch( SerializationException e )
        {
            log.error( e );
            ErrorHandler.handleError( null, e );
        }
        finally
        {
            if( re != null ) try{ re.destroy(); }catch( Exception e ){}
            if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
        }
    }

View Full Code Here


    /** @noinspection FieldRepeatedlyAccessedInMethod,JavaDoc*/
    public void save()
            throws SerializationException
    {
        RecordStore rs = null;
        try
        {
            rs = RecordStore.openRecordStore( RS_NAME, true );
            if( out != null )
            {
                baos.reset();
            }
            else
            {
                baos = new ByteArrayOutputStream();
                out = new SerializerOutputStream( baos );
            }
            serialize( out );
            final byte[] data = baos.toByteArray();
            if( recordId != null )
            {
                rs.setRecord( recordId.intValue(), data, 0, data.length );
            }
            else
            {
                recordId = new Integer( rs.addRecord( data, 0, data.length ) );
                cache.put( name, this );
            }
            dirty = false;
        }
        catch( RecordStoreException e )
        {
            log.error( e );
        }
        finally
        {
            if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
        }
    }

View Full Code Here


    public void delete()
    {
        if( recordId != null )
        {
            RecordStore rs = null;
            try
            {
                rs = RecordStore.openRecordStore( RS_NAME, true );
                rs.deleteRecord( recordId.intValue() );
            }
            catch( RecordStoreException e )
            {
                log.error( e );
            }
            finally
            {
                if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
            }
        }
        cache.remove( name );
    }

View Full Code Here

            pe.setCurrentValue( 0 );
            pe.setMaxValue( new Integer( count ) );
            pe.dispatch();
            for( int i = 0; i < count; i++ )
            {
                RecordStore rs = null;
                try
                {
                    rs = RecordStore.openRecordStore(
                            rsNames[i],
                            false
                    );
                    size += rs.getSize();
                    sizeAvailable = rs.getSizeAvailable();
                    buffer.append( rsNames[i] )
                            .append( ": " )
                            .append( rs.getSize() )
                            .append( "\n" );
                }
                catch( RecordStoreException e )
                {
                    throw e;
                }
                finally
                {
                    try{
                        if( rs != null )
                        {
                            rs.closeRecordStore();
                        } } catch( Exception e ){}
                }
                pe.increment();
                pe.dispatch();
            }
        }
        else
        {
            RecordStore rs = null;
            try
            {
                rs = RecordStore.openRecordStore( "_T_x_s_o_a_s_l_", true );
                sizeAvailable = rs.getSizeAvailable();
                rs.closeRecordStore();
                rs = null;
            }
            catch( RecordStoreException e )
            {
                throw e;
            }
            finally
            {
                try{ if( rs != null ) rs.closeRecordStore(); } catch( Exception e ){}
                RecordStore.deleteRecordStore( "_T_x_s_o_a_s_l_" );
            }
        }
        buffer.append( ResourceManager.getResource( "util.usedStorage" ) )
                .append( ": " )

View Full Code Here

    private int     displaySpeed;
    private boolean listFontBug;


    private static synchronized void load()
    {
        RecordStore rs = null;
        try
        {
            rs = RecordStore.openRecordStore( "sys_devinfo", true );
            final byte[] data = rs.getRecord( 1 );
            if( data != null )
            {
                final ByteArrayInputStream bais = new ByteArrayInputStream( data );
                final SerializerInputStream in = new SerializerInputStream( bais );
                final DeviceInfo deviceInfo = new DeviceInfo();
                deviceInfo.deserialize( in );
                DeviceInfo.setDeviceInfo( deviceInfo );
            }
        }
        catch( Exception e )
        {
        }
        finally
        {
            if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
        }
    }

View Full Code Here


    private static synchronized void save()
    {
        if( deviceInfo!= null )
        {
            RecordStore rs = null;
            try
            {
                final ByteArrayOutputStream baos = new ByteArrayOutputStream();
                final SerializerOutputStream out = new SerializerOutputStream( baos );
                deviceInfo.serialize( out );
                final byte[] data = baos.toByteArray();
                rs = RecordStore.openRecordStore( "sys_devinfo", true );
                if( rs.getNumRecords() == 0 )
                {
                    rs.addRecord( data, 0, data.length );
                }
                else
                {
                    rs.setRecord( 1, data, 0, data.length );
                }
            }
            catch( Exception e )
            {
            }
            finally
            {
                if( rs != null ) try{ rs.closeRecordStore(); }catch( Exception e ){}
            }
        }
    }

View Full Code Here


    private void checkAllocHandling()
    {
        try
        {
            RecordStore rs1 = RecordStore.openRecordStore( RSNAME1, true );
            rs_initialSize = rs1.getSizeAvailable();
            rs1.addRecord( new byte[ 100 ], 0, 100 );
            rs_availableAfterSet100 = rs1.getSizeAvailable();
            rs1.setRecord( 1, new byte[ 1000 ], 0, 1000 );
            rs_availableAfterSet1000 = rs1.getSizeAvailable();
            rs1.setRecord( 1, new byte[ 10000 ], 0, 10000 );
            rs_availableAfterIncreasedSet = rs1.getSizeAvailable();
            rs1.setRecord( 1, new byte[ 1000 ], 0, 1000 );
            rs_availableAfterReducedSet = rs1.getSizeAvailable();
            rs1.deleteRecord( 1 );
            rs_availableAfterDeleteRecord = rs1.getSizeAvailable();
            rs1.closeRecordStore();


            RecordStore.deleteRecordStore( RSNAME1 );


            rs1 = RecordStore.openRecordStore( RSNAME1, true );
            rs_availableAfterRSDelete = rs1.getSizeAvailable();
            rs1.closeRecordStore();


            RecordStore.deleteRecordStore( RSNAME1 );


            hasAllocBug = rs_availableAfterReducedSet < rs_availableAfterIncreasedSet;
            if( rs_availableAfterDeleteRecord == rs_initialSize )

View Full Code Here


    public static int getCurrentSizeLimit()
    {
        try
        {
            RecordStore rs = RecordStore.openRecordStore( RSNAME1, true );
            final int size = rs.getSizeAvailable();
            rs.closeRecordStore();
            return size;
        }
        catch( RecordStoreException e )
        {
            return -1;

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of javax.microedition.rms.RecordStore

bm.core.tools.DeviceInfo

bm.db.LoginInfo

bm.storage.StoreInfo

bm.storage.StoreInfoTest

bm.storage.StoreTest

bm.util.Util

com.funambol.syncclient.sps.ContactDataStore

com.funambol.syncclient.sps.EventDataStore

com.sun.midp.midlet.MIDletSuite

com.tinygo.pdb.DB

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.