Class Storage

java.lang.Object
com.codename1.io.Storage
public class Storage extends Object

Abstracts the underlying application specific storage system, unlike the com.codename1.io.FileSystemStorage this class is a higher level abstraction. The Storage class is designed to be very portable and as such it has no support for staple file system capabilities such as hierarchies.

Check out a more thorough discussion of this API here.

The sample code below shows a simple storage browser tool in action:

public void showForm() {
    Toolbar.setGlobalToolbar(true);
    Form hi = new Form("Storage", new BoxLayout(BoxLayout.Y_AXIS));
    hi.getToolbar().addCommandToRightBar("+", null, (e) -> {
        TextField tf = new TextField("", "File Name", 20, TextField.ANY);
        TextArea body = new TextArea(5, 20);
        body.setHint("File Body");
        Command ok = new Command("OK");
        Command cancel = new Command("Cancel");
        Command result = Dialog.show("File Name", BorderLayout.north(tf).add(BorderLayout.CENTER, body), ok, cancel);
        if(ok == result) {
            try(OutputStream os = Storage.getInstance().createOutputStream(tf.getText())) {
                os.write(body.getText().getBytes("UTF-8"));
                createFileEntry(hi, tf.getText());
                hi.getContentPane().animateLayout(250);
            } catch(IOException err) {
                Log.e(err);
            }
        }
    });

    for(String file : Storage.getInstance().listEntries()) {
        createFileEntry(hi, file);
    }
    hi.show();
}

private void createFileEntry(Form hi, String file) {
   Label fileField = new Label(file);
   Button delete = new Button();
   Button view = new Button();
   FontImage.setMaterialIcon(delete, FontImage.MATERIAL_DELETE);
   FontImage.setMaterialIcon(view, FontImage.MATERIAL_OPEN_IN_NEW);
   Container content = BorderLayout.center(fileField);
   int size = Storage.getInstance().entrySize(file);
   content.add(BorderLayout.EAST, BoxLayout.encloseX(new Label(size + "bytes"), delete, view));
   delete.addActionListener((e) -> {
       Storage.getInstance().deleteStorageFile(file);
       content.setY(hi.getWidth());
       hi.getContentPane().animateUnlayoutAndWait(150, 255);
       hi.removeComponent(content);
       hi.getContentPane().animateLayout(150);
   });
   view.addActionListener((e) -> {
       try(InputStream is = Storage.getInstance().createInputStream(file)) {
           String s = Util.readToString(is, "UTF-8");
           Dialog.show(file, s, "OK", null);
       } catch(IOException err) {
           Log.e(err);
       }
   });
   hi.add(content);
}

  • Constructor Summary

    Constructors
    Constructor
    Description
    Storage()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    clearCache()
    Storage is cached for faster access, however this might cause a problem with refreshing objects since they are not cloned.
    void
    clearStorage()
    Deletes all the files in the application storage
    InputStream
    createInputStream(String name)
    Creates an input stream to the given storage source file
    OutputStream
    createOutputStream(String name)
    Creates an output stream to the storage with the given name
    void
    deleteStorageFile(String name)
    Deletes the given file name from the storage
    int
    entrySize(String name)
    Returns the size in bytes of the given entry
    boolean
    exists(String name)
    Returns true if the given storage file exists
    void
    flushStorageCache()
    Flush the storage cache allowing implementations that cache storage objects to store
    static Storage
    getInstance()
    Returns the storage instance or null if the storage wasn't initialized using a call to init(String) first.
    static boolean
    isInitialized()
    Returns true if the storage is initialized
    boolean
    isNormalizeNames()
    Indicates whether characters that are typically illegal in filesystems should be sanitized and replaced with underscore
    String[]
    listEntries()
    Lists the names of the storage files
    Object
    readObject(String name)
    Reads the object from the storage, returns null if the object isn't there
    Object
    readObject(String name, boolean includeLogging)
    Reads the object from the storage, returns null if the object isn't there
    void
    setHardCacheSize(int size)
    Indicates the caching size, storage can be pretty slow
    void
    setNormalizeNames(boolean normalizeNames)
    Indicates whether characters that are typically illegal in filesystems should be sanitized and replaced with underscore
    static void
    setStorageInstance(Storage s)
    Allows installing a custom storage instance to provide functionality such as seamless encryption
    boolean
    writeObject(String name, Object o)
    Writes the given object to storage assuming it is an externalizable type or one of the supported types.
    boolean
    writeObject(String name, Object o, boolean includeLogging)
    Writes the given object to storage assuming it is an externalizable type or one of the supported types.

    Methods inherited from class Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • Storage

      public Storage()

  • Method Details

    • isInitialized

      public static boolean isInitialized()

      Returns true if the storage is initialized

      Returns

      true if the storage is initialized

    • getInstance

      public static Storage getInstance()

      Returns the storage instance or null if the storage wasn't initialized using a call to init(String) first.

      Returns

      storage instance

    • setStorageInstance

      public static void setStorageInstance(Storage s)

      Allows installing a custom storage instance to provide functionality such as seamless encryption

      Parameters
      • s: the storage instance

    • setHardCacheSize

      public void setHardCacheSize(int size)

      Indicates the caching size, storage can be pretty slow

      Parameters
      • size: size in elements (not kb!)

    • clearCache

      public void clearCache()
      Storage is cached for faster access, however this might cause a problem with refreshing objects since they are not cloned. Clearing the cache allows to actually reload from the storage file.

    • flushStorageCache

      public void flushStorageCache()
      Flush the storage cache allowing implementations that cache storage objects to store

    • deleteStorageFile

      public void deleteStorageFile(String name)

      Deletes the given file name from the storage

      Parameters
      • name: the name of the storage file

    • clearStorage

      public void clearStorage()
      Deletes all the files in the application storage

    • createOutputStream

      public OutputStream createOutputStream(String name) throws IOException

      Creates an output stream to the storage with the given name

      Parameters
      • name: the storage file name
      Returns

      an output stream of limited capacity

      Throws:
      IOException

    • createInputStream

      public InputStream createInputStream(String name) throws IOException

      Creates an input stream to the given storage source file

      Parameters
      • name: the name of the source file
      Returns

      the input stream

      Throws:
      IOException

    • exists

      public boolean exists(String name)

      Returns true if the given storage file exists

      Parameters
      • name: the storage file name
      Returns

      true if it exists

    • listEntries

      public String[] listEntries()

      Lists the names of the storage files

      Returns

      the names of all the storage files

    • entrySize

      public int entrySize(String name)

      Returns the size in bytes of the given entry

      Parameters
      • name: the name of the entry
      Returns

      the size in bytes

    • writeObject

      public boolean writeObject(String name, Object o)

      Writes the given object to storage assuming it is an externalizable type or one of the supported types.

      The sample below demonstrates the usage and registration of the com.codename1.io.Externalizable interface:

      // File: Main.java
public Main {
  public void init(Object o) {
    theme = UIManager.initFirstTheme("/theme");

    // IMPORTANT: Notice we don't use MyClass.class.getName()! This won't work due to obfuscation!
    Util.register("MyClass", MyClass.class);
  }

  public void start() {
    //...
  }

  public void stop() {
    //...
  }

  public void destroy() {
    //...
  }
}

      // File: MyClass.java
public MyClass implements Externalizable {
  // allows us to manipulate the version, in this case we are demonstrating a data change between the initial release
  // and the current state of object data
  private static final int VERSION = 2;

  private String name;
  private Map data;

  // this field was added after version 1
  private Date startedAt;

  public int getVersion() {
    return VERSION;
  }

  public void externalize(DataOutputStream out) throws IOException {
    Util.writeUTF(name, out);
    Util.writeObject(data, out);
    if(startedAt != null) {
        out.writeBoolean(true);
        out.writeLong(startedAt.getTime());
    } else {
        out.writeBoolean(false);
    }
  }
  public void internalize(int version, DataInputStream in) throws IOException {
    name = Util.readUTF(in);
    data = (Map)Util.readObject(in);
    if(version > 1) {
        boolean hasDate = in.readBoolean();
        if(hasDate) {
            startedAt = new Date(in.readLong());
        }
    }
  }
  public String getObjectId() {
    // IMPORTANT: Notice we don't use getClass().getName()! This won't work due to obfuscation!
    return "MyClass";
  }
}

      // File: ReadAndWrite.java
// will read the file or return null if failed
MyClass object = (MyClass)Storage.getInstance().readObject("NameOfFile");

// write the object back to storage
Storage.getInstance().writeObject("NameOfFile", object);
      Parameters

      • name: store name

      • o: object to store

      Returns

      true for success, false for failure

    • writeObject

      public boolean writeObject(String name, Object o, boolean includeLogging)

      Writes the given object to storage assuming it is an externalizable type or one of the supported types.

      The sample below demonstrates the usage and registration of the com.codename1.io.Externalizable interface:

      // File: Main.java
public Main {
  public void init(Object o) {
    theme = UIManager.initFirstTheme("/theme");

    // IMPORTANT: Notice we don't use MyClass.class.getName()! This won't work due to obfuscation!
    Util.register("MyClass", MyClass.class);
  }

  public void start() {
    //...
  }

  public void stop() {
    //...
  }

  public void destroy() {
    //...
  }
}

      // File: MyClass.java
public MyClass implements Externalizable {
  // allows us to manipulate the version, in this case we are demonstrating a data change between the initial release
  // and the current state of object data
  private static final int VERSION = 2;

  private String name;
  private Map data;

  // this field was added after version 1
  private Date startedAt;

  public int getVersion() {
    return VERSION;
  }

  public void externalize(DataOutputStream out) throws IOException {
    Util.writeUTF(name, out);
    Util.writeObject(data, out);
    if(startedAt != null) {
        out.writeBoolean(true);
        out.writeLong(startedAt.getTime());
    } else {
        out.writeBoolean(false);
    }
  }
  public void internalize(int version, DataInputStream in) throws IOException {
    name = Util.readUTF(in);
    data = (Map)Util.readObject(in);
    if(version > 1) {
        boolean hasDate = in.readBoolean();
        if(hasDate) {
            startedAt = new Date(in.readLong());
        }
    }
  }
  public String getObjectId() {
    // IMPORTANT: Notice we don't use getClass().getName()! This won't work due to obfuscation!
    return "MyClass";
  }
}

      // File: ReadAndWrite.java
// will read the file or return null if failed
MyClass object = (MyClass)Storage.getInstance().readObject("NameOfFile");

// write the object back to storage
Storage.getInstance().writeObject("NameOfFile", object);
      Parameters

      • name: store name

      • o: object to store

      • includeLogging: During app initialization, the logging on error might impact the apps stability

      Returns

      true for success, false for failure

    • readObject

      public Object readObject(String name)

      Reads the object from the storage, returns null if the object isn't there

      The sample below demonstrates the usage and registration of the com.codename1.io.Externalizable interface:

      // File: Main.java
public Main {
  public void init(Object o) {
    theme = UIManager.initFirstTheme("/theme");

    // IMPORTANT: Notice we don't use MyClass.class.getName()! This won't work due to obfuscation!
    Util.register("MyClass", MyClass.class);
  }

  public void start() {
    //...
  }

  public void stop() {
    //...
  }

  public void destroy() {
    //...
  }
}

      // File: MyClass.java
public MyClass implements Externalizable {
  // allows us to manipulate the version, in this case we are demonstrating a data change between the initial release
  // and the current state of object data
  private static final int VERSION = 2;

  private String name;
  private Map data;

  // this field was added after version 1
  private Date startedAt;

  public int getVersion() {
    return VERSION;
  }

  public void externalize(DataOutputStream out) throws IOException {
    Util.writeUTF(name, out);
    Util.writeObject(data, out);
    if(startedAt != null) {
        out.writeBoolean(true);
        out.writeLong(startedAt.getTime());
    } else {
        out.writeBoolean(false);
    }
  }
  public void internalize(int version, DataInputStream in) throws IOException {
    name = Util.readUTF(in);
    data = (Map)Util.readObject(in);
    if(version > 1) {
        boolean hasDate = in.readBoolean();
        if(hasDate) {
            startedAt = new Date(in.readLong());
        }
    }
  }
  public String getObjectId() {
    // IMPORTANT: Notice we don't use getClass().getName()! This won't work due to obfuscation!
    return "MyClass";
  }
}

      // File: ReadAndWrite.java
// will read the file or return null if failed
MyClass object = (MyClass)Storage.getInstance().readObject("NameOfFile");

// write the object back to storage
Storage.getInstance().writeObject("NameOfFile", object);
      Parameters
      • name: name of the store
      Returns

      object stored under that name

    • readObject

      public Object readObject(String name, boolean includeLogging)

      Reads the object from the storage, returns null if the object isn't there

      The sample below demonstrates the usage and registration of the com.codename1.io.Externalizable interface:

      // File: Main.java
public Main {
  public void init(Object o) {
    theme = UIManager.initFirstTheme("/theme");

    // IMPORTANT: Notice we don't use MyClass.class.getName()! This won't work due to obfuscation!
    Util.register("MyClass", MyClass.class);
  }

  public void start() {
    //...
  }

  public void stop() {
    //...
  }

  public void destroy() {
    //...
  }
}

      // File: MyClass.java
public MyClass implements Externalizable {
  // allows us to manipulate the version, in this case we are demonstrating a data change between the initial release
  // and the current state of object data
  private static final int VERSION = 2;

  private String name;
  private Map data;

  // this field was added after version 1
  private Date startedAt;

  public int getVersion() {
    return VERSION;
  }

  public void externalize(DataOutputStream out) throws IOException {
    Util.writeUTF(name, out);
    Util.writeObject(data, out);
    if(startedAt != null) {
        out.writeBoolean(true);
        out.writeLong(startedAt.getTime());
    } else {
        out.writeBoolean(false);
    }
  }
  public void internalize(int version, DataInputStream in) throws IOException {
    name = Util.readUTF(in);
    data = (Map)Util.readObject(in);
    if(version > 1) {
        boolean hasDate = in.readBoolean();
        if(hasDate) {
            startedAt = new Date(in.readLong());
        }
    }
  }
  public String getObjectId() {
    // IMPORTANT: Notice we don't use getClass().getName()! This won't work due to obfuscation!
    return "MyClass";
  }
}

      // File: ReadAndWrite.java
// will read the file or return null if failed
MyClass object = (MyClass)Storage.getInstance().readObject("NameOfFile");

// write the object back to storage
Storage.getInstance().writeObject("NameOfFile", object);
      Parameters

      • name: name of the store

      • includeLogging: During app initialization, the logging on error might impact the apps stability

      Returns

      object stored under that name

    • isNormalizeNames

      public boolean isNormalizeNames()

      Indicates whether characters that are typically illegal in filesystems should be sanitized and replaced with underscore

      Returns

      the normalizeNames

    • setNormalizeNames

      public void setNormalizeNames(boolean normalizeNames)

      Indicates whether characters that are typically illegal in filesystems should be sanitized and replaced with underscore

      Parameters
      • normalizeNames: the normalizeNames to set