Tutorial: Demo Project

Search…
Walk-through of an example Android note taking app using ObjectBox.
What is ObjectBox? It’s a standalone database that makes object persistence simple and super fast.
This tutorial will walk you through a simple note-taking app explaining how to do basic operations with ObjectBox. To just integrate ObjectBox into your project, look at the Getting Started page.
You can check out the example code from GitHub. This allows you to run the code and explore it in its entirety. It is a simple Android app for taking notes where you can add new notes by typing in some text and delete notes by clicking on an existing note.
Java
Kotlin
Dart
1
git clone https://github.com/objectbox/objectbox-examples.git
2
cd objectbox-examples/android-app
Copied!
1
git clone https://github.com/objectbox/objectbox-examples.git
2
cd objectbox-examples/android-app-kotlin
Copied!
1
git clone https://github.com/objectbox/objectbox-dart.git
2
cd objectbox-dart/objectbox/examples/flutter/objectbox_demo
Copied!
The Note entity and Box class
To begin let’s jump right into the code: among the sources the entity class:Note. It is persisted (saved) in the database and contains all data that is part of a note, like an id, note text and the creation date.
Java
Kotlin
Dart
src/Note.java
1
@Entity
2
public class Note {
3
    
4
    @Id
5
    long id;
6
    
7
    String text;
8
    String comment;
9
    Date date;
10
    
11
    ...
12
}
Copied!
src/Note.kt
1
@Entity
2
data class Note(
3
        @Id var id: Long = 0,
4
        var text: String? = null,
5
        var comment: String? = null,
6
        var date: Date? = null
7
)
Copied!
lib/main.dart
1
@Entity()
2
class Note {
3
  int id;
4
  String text;
5
  String? comment;
6
  DateTime date;
7
​
8
  ...
9
}
Copied!
In general, an ObjectBox entity is an annotated class persisted in the database with its properties. In order to extend our note or to create new entities, you simply modify or create new plain classes and annotate them with @Entity and @Id.
Entity Annotations
Java
Kotlin
Dart
Go ahead and build the project, for example by using Build > Make project in Android Studio. This triggers ObjectBox to generate some classes, like MyObjectBox.java, and some other classes used by ObjectBox internally.
Go ahead and build the project, for example by using Build > Make project in Android Studio. This triggers ObjectBox to generate some classes, like MyObjectBox.kt, and some other classes used by ObjectBox internally.
To generate ObjectBox binding code for your entities, make sure to run pub run build_runner build after making any changes to the entity classes. ObjectBox generator will look for all @Entity annotations in your lib folder and create a single database definition lib/objectbox-model.json and supporting code in lib/objectbox.g.dart. 
You should commit objectbox-model.json into your source control (e.g. git) and add objectbox.g.dart to the ignore list (e.g. .gitignore), otherwise, the build_runner will complain about it being changed each time you pull a change.
The generator will process lib and test folders separately and create a separate database in each if it finds annotated entities there. This is useful if you need a separate test database. If you're just writing tests for your own code, you won't have any annotations in the test folder so no DB  model will be created there.
Inserting notes
To see how new notes are added to the database, take a look at the following code fragments. The Box<Note> provides database operations for Note objects.
Java
Kotlin
Dart
NoteActivity.java
1
@Override
2
public void onCreate(Bundle savedInstanceState) {
3
    ...
4
    notesBox = ObjectBox.get().boxFor(Note.class);
5
    ...
6
}
Copied!
Note: In the example project, ObjectBox is the name of a helper class to set up and keep a reference to BoxStore.
NoteActivity.kt
1
public override fun onCreate(savedInstanceState: Bundle?) {
2
    ...
3
    notesBox = ObjectBox.boxStore.boxFor()
4
    ...
5
}
Copied!
Note: In the example project, ObjectBox is the name of a helper class to set up and keep a reference to BoxStore.
lib/main.dart
1
class ViewModel {
2
  final Store _store;
3
  late final Box<Note> _box;
4
  
5
  ViewModel(Directory dir)
6
      : _store = Store(getObjectBoxModel(), directory: dir.path + '/objectbox') {
7
    _box = _store.box<Note>();
8
  }
9
  
10
  ...
Copied!
When a user clicks the ADD button the method addNote() is called. There, a new Note object is created and put into the database using the Box reference:
Java
Kotlin
Dart
NoteActivity.java
1
private void addNote() {
2
    ...
3
    Note note = new Note();
4
    note.setText(noteText);
5
    note.setComment(comment);
6
    note.setDate(new Date());
7
    notesBox.put(note);
8
    Log.d(App.TAG, "Inserted new note, ID: " + note.getId());
9
    ...
10
}
Copied!
NoteActivity.kt
1
private fun addNote() {
2
    ...
3
    val note = Note(text = noteText, comment = comment, date = Date())
4
    notesBox.put(note)
5
    Log.d(App.TAG, "Inserted new note, ID: " + note.id)
6
    ...
7
}
Copied!
1
void addNote() {
2
  _box.put(Note(_noteInputController.text));
3
}
Copied!
Note that the ID property (0 when creating the Note object), is assigned by ObjectBox during put().
Removing/deleting notes
When the user taps a note, it is deleted. The Box provides remove() to achieve this:
Java
Kotlin
Dart
NoteActivity.java
1
OnItemClickListener noteClickListener = new OnItemClickListener() {
2
    @Override
3
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
4
        Note note = notesAdapter.getItem(position);
5
        notesBox.remove(note);
6
        Log.d(App.TAG, "Deleted note, ID: " + note.getId());
7
        ...
8
    }
9
};
Copied!
NoteActivity.kt
1
private val noteClickListener = OnItemClickListener { _, _, position, _ ->
2
    notesAdapter.getItem(position)?.also {
3
        notesBox.remove(it)
4
        Log.d(App.TAG, "Deleted note, ID: " + it.id)
5
    }
6
    ...
7
}
Copied!
1
...
2
onTap: () => _vm._box.remove(notes[index].id),
3
...
Copied!
Querying notes
To query and display notes with a list adapter a Query instance is built once:
Java
Kotlin
Dart
NoteActivity.java
1
@Override
2
public void onCreate(Bundle savedInstanceState) {
3
    ...
4
    // Query all notes, sorted a-z by their text.
5
    notesQuery = notesBox.query().order(Note_.text).build();
6
    ...
7
}
Copied!
NoteActivity.kt
1
public override fun onCreate(savedInstanceState: Bundle?) {
2
    ...
3
    // Query all notes, sorted a-z by their text.
4
    notesQuery = notesBox.query {
5
        order(Note_.text)
6
    }
7
    ...
8
}
Copied!
1
class ViewModel {
2
  final Store _store;
3
  late final Box<Note> _box;
4
  late final Query<Note> _query;
5
  
6
  ViewModel(Directory dir)
7
      : _store = Store(getObjectBoxModel(), directory: dir.path + '/objectbox') {
8
    _box = _store.box<Note>();
9
    _query = _box.query().order(Note_.date, flags: Order.descending).build();
10
  }
11
  
12
  ...
Copied!
And then executed each time any notes change:
Java
Kotlin
Dart
NoteActivity.java
1
private void updateNotes() {
2
    List<Note> notes = notesQuery.find();
3
    notesAdapter.setNotes(notes);
4
}
Copied!
NoteActivity.kt
1
private fun updateNotes() {
2
    val notes = notesQuery.find()
3
    notesAdapter.setNotes(notes)
4
}
Copied!
1
List<Note> get allNotes => _query.find();
Copied!
In addition to an order, you can add various conditions, like equality or less/greater than, when building a query.
ObjectBox Queries
Updating notes and more
What is not shown in the example, is how to update an existing (== the ID is not 0) note. Just modify any of its properties and call put() again with the changed object:
Java
Kotlin
Dart
1
note.setText("This note has changed.");
2
notesBox.put(note);
Copied!
1
note.text = "This note has changed."
2
notesBox.put(note)
Copied!
1
note.text = "This note has changed.";
2
_box.put(note);
Copied!
There are additional methods to put, find, query, count or remove entities. Check out the methods of the Box class in API docs (for Java/Kotlin or Dart) to learn more.
Getting started
Setting up the database
Now that you saw ObjectBox in action, how did we get that BoxStore instance? Typically you should set up a BoxStore once for the whole app. This example uses a helper class as recommended in the Getting Started guide.
Getting started
Remember: ObjectBox is a NoSQL database on its own and thus NOT based on SQL or SQLite. That’s why you do not need to set up “CREATE TABLE” statements during initialization.
Note: it is perfectly fine to never close the database. That’s even recommended for most apps.
Getting started
Entity Annotations
Last modified 5mo ago
Export as PDF
Copy link
Contents
The Note entity and Box class
Inserting notes
Removing/deleting notes
Querying notes
Updating notes and more
Setting up the database