Team:

• Reché Kirkland (reche.kirkland@gmail.com)
• Stepan Tikhonov (stepan.tikhonov@gmail.com)

Products:

• RakuGaku - An all-in-one learning tool for Kanji and Japanese Language Learning.
• ModelPersistence - An Object-Relational Mapping (OR/M) System that takes Plain old Java Objects (POJOs) and stores them to any database or XML type for Android and standard Java.

Files: 

RakuGaku_12wk_Commitment.pdf

RakuGaku_12w_Final.pdf

RakuGaku 

Overview:

This is a continuation of our 3-week app, but we are expanding the features to allow a more flexible learning environment.  The final product will include kanji, grammar, writing testing.

Features:

• Integrated platform
• Browse through thousands of characters 
• Allows for customization and expansion
• Allows students and users to take control of their learning experience 
• Integrated lesson plans 
• Track and identify weaknesses

Screenshots:

ModelPersistence

Raison d'Etre:

In working with our RakuGaku project, it became clear that making rapid changes to the UI was required to allow for us to work with non-technical advisors. In order to do this, we decided that it was too costly to have to perpetually change and modify the UI, the SQL interface to the UI, the databases, and the SQL scripts that loaded the databases. So we decided to create a nice tool to allow us to forget about SQL and databases altogether. The UI is entirely bound to the interface methods of the classes that we use and the databases are tied to the fields of those objects so there is flexibility from the UI to the database and no SQL has to be written, changed, or maintained...EVER.

Overview:

Integrated Object-Relational Mapping (OR/M) Library.

• Provides a transparent SQLite/JDBC/XML persistence layer for Android and Java.
• Produces Fully Normalized, Human Readable databases for ease of integration with other, existing, code.
• Allows for reading existing sources and creates new sources dynamically. Examples are reading the base Android app databases within Java dynamically and being able to write entries back to them all without any SQL knowledge at all.

Example Code:

Object Example: This is a sample Java POJO for use within our system; a developer can make much more complex objects and the code works the same. 

    @Entity

    public class MyObject{

        @Id

        Integer id;

        String name;

        MyOtherObject[] stuff;
        private MyObject()
        {
        }
        public MyObject(String name)
        { this.name = name; }  
   }

    @Entity

    public class MyOtherObject{

        @Id

        Integer id;

        long someLong;
        double someDouble; 

        private MyOtherObject()
        {
        }
   }

From this example, the only things required by our application are:

1. @Entity attributes to be present on any class you want the library to store
2. Classes must contain an @Id field of type Integer.
3. A no argument constructor of any level of visibility for each class stored. 

These are not strictly necessary but we enforce them for sanity checking (to prevent users from trying to store Socket objects or the like).

Store Example:

    ModelFactory factory = ModelFactory.GetDefaultInstance();

    MyObject stuff = new MyObject("SampleObject");

    ...

    // The actual point the stuff object is persisted 

    factory.store(stuff);

Search Example:

    ModelConstraint modelConstraint = new ModelConstraint(null, MyObject.class);

    modelConstraint.addConstraint("name", ModelConstraint.Relationship.EQUALS, false, "SampleObject");

    // Search for matching sources

    List<MyObject> results = ModelFactory.Find(MyObject.class,constraints);

The results list now contains any objects that match the constraints, including the instance created in the Store example.