Android GreenDao with Android Studio IDE

时间：2021-05-19 22:43:47

转：http://blog.surecase.eu/using-greendao-with-android-studio-ide/

In this tutorial we will show you step by step how we have created sample application that presents our own Android Studio-GreenDao communication module. We tried to focus mainly on the implementation of database in freshly created Android Studio project and took other factors (such as layouts, modularity etc.) with a grain of salt. For those who haven't checked our Git yet - you can find our GreenDao module here.

So let's get started!

Step 1 - create new Android Project

For those who are not familiar with Android Studio IDE we recommend to go through Google tutorial - Getting Started With Android Studio.

  1. To create new project please select File -> New Project. The New Project wizards pop up. Fill up fields according to your liking or do it the way we did: 
    Android GreenDao with Android Studio IDE

    1. Press next. Check "Blank Activity" and next button again.
    2. Name your first activity BoxListActivity and the layout activity_box_list.
    3. Press finish.

And it's done. We have our project created. Now we can go to next step which is...

Step 2 - add GreenDao Generator module to project tree

We assume you have already downloaded our module. If not please go to our Git and do it now. Add MyDaoGenerator module to your project tree as additional package.

Android GreenDao with Android Studio IDE

As you can see MyDaoGenerator is recognized as Directory and not as Module like DaoExample. To change it we have to edit settings.gradle so it contains both ':DaoExample' and ':MyDaoGenerator' :

include ':DaoExample', ':MyDaoGenerator'

After doing it, please click "Sync Project with Gradle Files" button. Your directory should look like a module now in project tree.

Step 3 - connect GreenDao Generator to DaoExample (main module)

So, MyDaoGenerator is currently recognized as a module. Now we have to configure it, so we can get database files from it. The only necessary thing to be changed is outputDir parameter inbuild.gradle file of MyDaoGenerator module.

12345678910111213141516171819202122
project(':MyDaoGenerator') {
apply plugin: 'application'
apply plugin: 'java'
 
mainClassName = "pl.surecase.eu.MyDaoGenerator"
// edit output direction
outputDir =
 
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile('de.greenrobot:DaoGenerator:1.3.0')
}
 
task createDocs {
def docs = file(outputDir)
docs.mkdirs()
}
 
run {
args outputDir
}
}

Currently our root is MyDaoGenerator. We want to access DaoExample, which needs database files. To go higher - our path will start with:

outputDir = "../"

We are currently in GreenDaoForAndroidStudio folder. We can easly go into DaoExample and create a directory for our database files. Java files in Android Studio project are stored in ../<PROJECT NAME>/src/main/java directory. To highlight the fact, that GreenDao database files are generated and will change in future as your project develops, we decided to create separate directory for them named java-gen.

Finaly our path looks like:

outputDir = "../DaoExample/src/main/java-gen"

There is no need to create this directory manualy. After running MyDaoGenerator it will be created during build.

Your GreenDao generator is now ready to inject database files to your project.

Step 4 - configure GreenDao Generator

MyDaoGenerator consists of only one class:

Android GreenDao with Android Studio IDE

Output of GreenDao Generator is deremined by content of MyDaoGenerator.class. You can create your database structure here by coding objects, relations etc. If you are not familiar with GreenDao database library, you can learn how to use it in that documentation.

We will create exemplary database with only one object. Database code needs to be placed in main method:

public class MyDaoGenerator {

    public static void main(String args[]) throws Exception {

    }

}

Create Schema object with represents database version and package. We will name the package greendao.

Schema schema = new Schema(3, "greendao");

We create Entity - database object which will be named Box.

Entity box = schema.addEntity("Box");

Now we can add properties/fields to our database Entity/Object. For example:

  • id
box.addIdProperty();
  • String name 
box.addStringProperty("name");
  • int slots 
box.addIntProperty("slots");
  • String description 
box.addStringProperty("description");

Finaly we can invoke DaoGenerator object which is avaliable by default in MyDaoGenerator due to Maven tool (check gradle.build and dependencies section). DaoGenerator during run will create database java files that can be used in our main project. It takes two parameters: Schema and output directory.

new DaoGenerator().generateAll(schema, args[0]);

When you look at gradle.build there is a run section in which outputDir parameter is being sent to main method as an argument. That's why args[0] will always contain output path that you have set previously in gradle. Such operation limits actions performed on MyDaoGenerator to only three steps:

  • set path in gradle.build file
  • create your database in MyDaoGenerator.class
  • run module

Step 5 - run GreenDao Generator

Pick Gradle bookmark from the right side of Android Studio interface. Choose MyDaoGenerator module and click twice on run task.

Android GreenDao with Android Studio IDE

greenDAO Generator

Copyright 2011-2013 Markus Junginger, greenrobot.de. Licensed under GPL V3.

This program comes with ABSOLUTELY NO WARRANTY

Processing schema version 3...

Written /Users/surecase/dev/examples/GreenDaoForAndroidStudio/GreenDaoForAndroidStudio/DaoExample/src/main/java-gen/greendao/BoxDao.java

Written /Users/surecase/dev/examples/GreenDaoForAndroidStudio/GreenDaoForAndroidStudio/DaoExample/src/main/java-gen/greendao/Box.java

Written /Users/surecase/dev/examples/GreenDaoForAndroidStudio/GreenDaoForAndroidStudio/DaoExample/src/main/java-gen/greendao/DaoMaster.java

Written /Users/surecase/dev/examples/GreenDaoForAndroidStudio/GreenDaoForAndroidStudio/DaoExample/src/main/java-gen/greendao/DaoSession.java

Processed 1 entities in 103ms

BUILD SUCCESSFUL

Total time: 8.802 secs

After starting run task, you can track flow of this operation in Gradle console. When it's complete you can see new files in DaoExample project:

Android GreenDao with Android Studio IDE

And that's all work connected to MyDaoGenerator. If you are familiar with it, generation of new database will take only few minutes.

Step 6 - make DaoExample aware of new files

So we have successfully created database files that are ready to be used in any Android project. The project needs to be aware where are those files located and familiar with GreenDao objects. To achieve this it is necessary to configure build.gradle file of DaoExample module. Fresh build.gradle file of a new project looks similar to this:

123456789101112131415161718192021222324
apply plugin: 'android'
 
android {
compileSdkVersion 19
buildToolsVersion "19.0.3"
 
defaultConfig {
minSdkVersion 11
targetSdkVersion 19
versionCode 1
versionName "1.0"
}
buildTypes {
release {
runProguard false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
}
}
}
 
dependencies {
compile 'com.android.support:appcompat-v7:+'
compile fileTree(dir: 'libs', include: ['*.jar'])
}
view rawdefaultGradle.groovy hosted with ❤ by GitHub
  • We need to clean it first from features that we won't use in our project - buildTypes section is not needed.
  • To let our project use GreenDao database, first we need to import GreenDao library. We can do it by inserting *.jar file into libs folder or by adding extra Maven dependency in gradle:
 dependencies {

    compile 'de.greenrobot:greendao:1.3.7'

}
  • Project is still not aware of new Java files because it isn't located in ../<PROJECT NAME>/src/main/java directory. To fix this we must specify projects source sets. It is important to point two java file sources: /src/main/java and /src/main/java-gen. You can do it by placingsourceSets section into android section in gradle.build file:
12345678910
android {
 
sourceSets {
main {
manifest.srcFile 'src/main/AndroidManifest.xml'
java.srcDirs = ['src/main/java', 'src/main/java-gen']
res.srcDirs = ['src/main/res']
}
}
}
view rawsourceSets.groovy hosted with ❤ by GitHub

Finaly our gradle will look like this:

12345678910111213141516171819202122232425262728
apply plugin: 'android'
 
android {
compileSdkVersion 19
buildToolsVersion "19.0.3"
 
defaultConfig {
minSdkVersion 11
targetSdkVersion 19
versionCode 1
versionName "1.0"
}
 
sourceSets {
main {
manifest.srcFile 'src/main/AndroidManifest.xml'
java.srcDirs = ['src/main/java', 'src/main/java-gen']
res.srcDirs = ['src/main/res']
}
}
 
}
 
dependencies {
compile 'com.android.support:appcompat-v7:+'
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'de.greenrobot:greendao:1.3.7'
}
view raweditedGradle.groovy hosted with ❤ by GitHub

When you finish editing gradle file, press "Sync Project with Gradle Files" button. Your java-gen directory will look the same as java folder in project tree.

Step 7 - start Database

Your project is ready to use previously created database. To have access to GreenDao database, you have to initialize it before using it. Right place for performing this operation is Application class which is instantiated for you when the process for your application/package is created. Initialization code can be found on GreenDao webpage. Application is avaliable from every activity, so we create DaoSession object which is avaliable during whole lifecycle of application and create getter for it.

12345678910111213141516171819202122
public class DaoExampleApplication extends Application {
 
public DaoSession daoSession;
 
@Override
public void onCreate() {
super.onCreate();
setupDatabase();
}
 
private void setupDatabase() {
DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "example-db", null);
SQLiteDatabase db = helper.getWritableDatabase();
DaoMaster daoMaster = new DaoMaster(db);
daoSession = daoMaster.newSession();
}
 
public DaoSession getDaoSession() {
return daoSession;
}
 
}

Don't forget to register DaoExampleApplication class in your manifest:

<application

    android:name=".DaoExampleApplication"

    (...)

</application>

Step 8 - simple operations on DB object

Database generated in this tutorial has only one Entity - Box. To perform create, edit, save, delete on it, we need too create helper class with those methods. We name it BoxRepository. Each Entity created in GreenDao has two classes:

  • class that represents structure of object
  • Dao class which is a connection of object with database

In our example those clasess are named as Box and BoxDao. So if we want start working with Box objects we need to get BoxDao object from DaoSession that was created with Application class.

private static BoxDao getBoxDao(Context c) {

    return ((DaoExampleApplication) c.getApplicationContext()).getDaoSession().getBoxDao();

}

With access to DaoBox we can perform any operation on Box object we need. Examplary BoxRepository from our project looks like this:

1234567891011121314151617181920212223242526
public class BoxRepository {
 
public static void insertOrUpdate(Context context, Box box) {
getBoxDao(context).insertOrReplace(box);
}
 
public static void clearBoxes(Context context) {
getBoxDao(context).deleteAll();
}
 
public static void deleteBoxWithId(Context context, long id) {
getBoxDao(context).delete(getBoxForId(context, id));
}
 
public static List<Box> getAllBoxes(Context context) {
return getBoxDao(context).loadAll();
}
 
public static Box getBoxForId(Context context, long id) {
return getBoxDao(context).load(id);
}
 
private static BoxDao getBoxDao(Context c) {
return ((DaoExampleApplication) c.getApplicationContext()).getDaoSession().getBoxDao();
}
}
view rawboxRepository.java hosted with ❤ by GitHub

Examplary use that can be used in every place where Context is avaliable:

Box box = new Box();

box.setId(5); // if box with id 5 already exists in DB, it will be edited instead of created

box.setName("My box");

box.setSlots(39);

box.setDescription("This is my box. I can put in it anything I wish.");

BoxRepository.insertOrUpdate(context, box);

Step 9 - rest is up to you

This is the end of this tutorial. You have all information and tools you need to start work with GreenDao database in your Android Studio project. There is no need to show you how to create views, buttons, adapters etc. If you are interested in it - whole source code and project structure of GreenDaoForAndroidStudio sample project is avaliable at SureCase git.

相关文章