228 lines
7.8 KiB
Java
Executable File
228 lines
7.8 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2008 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
|
* the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*/
|
|
|
|
package com.openwide.android;
|
|
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.database.Cursor;
|
|
import android.database.SQLException;
|
|
import android.database.sqlite.SQLiteDatabase;
|
|
import android.database.sqlite.SQLiteOpenHelper;
|
|
import android.provider.Contacts.Phones;
|
|
import android.util.Log;
|
|
|
|
/**
|
|
* Simple groups database access helper class. Defines the basic CRUD operations
|
|
* for the grouppad example, and gives the ability to list all groups as well as
|
|
* retrieve or modify a specific group.
|
|
*
|
|
* This has been improved from the first version of this tutorial through the
|
|
* addition of better error handling and also using returning a Cursor instead
|
|
* of using a collection of inner classes (which is less scalable and not
|
|
* recommended).
|
|
*/
|
|
public class GroupsDbAdapter {
|
|
|
|
|
|
public static final String KEY_GROUP_NAME = "name";
|
|
public static final String KEY_GROUP_ROWID = "_id";
|
|
|
|
public static final String KEY_GROUP_TO_PHONE_ROWID = "_id";
|
|
public static final String KEY_GROUP_TO_PHONE_GROUPID = "gid";
|
|
public static final String KEY_GROUP_TO_PHONE_PHONEID = "pid";
|
|
|
|
private static final String TAG = "groupsDbAdapter";
|
|
private DatabaseHelper mDbHelper;
|
|
private SQLiteDatabase mDb;
|
|
|
|
/**
|
|
* Database creation sql statement
|
|
*/
|
|
private static final String DATABASE_GROUP_CREATE =
|
|
"create table groups (_id integer primary key autoincrement, "
|
|
+ "name text not null);";
|
|
|
|
private static final String DATABASE_GROUP_TO_PHONE_CREATE =
|
|
"create table group_TO_PHONE (_id integer primary key autoincrement, "
|
|
+ "gid integer not null, pid integer not null);";
|
|
|
|
private static final String DATABASE_NAME = "data";
|
|
private static final String DATABASE_GROUP_TABLE = "groups";
|
|
private static final String DATABASE_GROUP_TO_PHONE_TABLE = "group_TO_PHONE";
|
|
private static final int DATABASE_VERSION = 2;
|
|
|
|
private final Context mCtx;
|
|
|
|
private static class DatabaseHelper extends SQLiteOpenHelper {
|
|
|
|
DatabaseHelper(Context context) {
|
|
super(context, DATABASE_NAME, null, DATABASE_VERSION);
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(SQLiteDatabase db) {
|
|
|
|
db.execSQL(DATABASE_GROUP_CREATE);
|
|
db.execSQL(DATABASE_GROUP_TO_PHONE_CREATE);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
|
|
Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
|
|
+ newVersion + ", which will destroy all old data");
|
|
db.execSQL("DROP TABLE IF EXISTS groups");
|
|
db.execSQL("DROP TABLE IF EXISTS group_TO_PHONE");
|
|
onCreate(db);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructor - takes the context to allow the database to be
|
|
* opened/created
|
|
*
|
|
* @param ctx the Context within which to work
|
|
*/
|
|
public GroupsDbAdapter(Context ctx) {
|
|
this.mCtx = ctx;
|
|
}
|
|
|
|
/**
|
|
* Open the groups database. If it cannot be opened, try to create a new
|
|
* instance of the database. If it cannot be created, throw an exception to
|
|
* signal the failure
|
|
*
|
|
* @return this (self reference, allowing this to be chained in an
|
|
* initialization call)
|
|
* @throws SQLException if the database could be neither opened or created
|
|
*/
|
|
public GroupsDbAdapter open() throws SQLException {
|
|
mDbHelper = new DatabaseHelper(mCtx);
|
|
mDb = mDbHelper.getWritableDatabase();
|
|
return this;
|
|
}
|
|
|
|
public void close() {
|
|
mDbHelper.close();
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a new group using the name provided. If the group is
|
|
* successfully created return the new rowId for that group, otherwise return
|
|
* a -1 to indicate failure.
|
|
*
|
|
* @param name the name of the group
|
|
*/
|
|
public long createGroup(String name) {
|
|
ContentValues initialValues = new ContentValues();
|
|
initialValues.put(KEY_GROUP_NAME, name);
|
|
|
|
return mDb.insert(DATABASE_GROUP_TABLE, null, initialValues);
|
|
}
|
|
|
|
/**
|
|
* Delete the group with the given rowId
|
|
*
|
|
* @param rowId id of group to delete
|
|
* @return true if deleted, false otherwise
|
|
*/
|
|
public boolean deleteGroup(long rowId) {
|
|
|
|
return mDb.delete(DATABASE_GROUP_TABLE, KEY_GROUP_ROWID + "=" + rowId, null) > 0 && mDb.delete(DATABASE_GROUP_TO_PHONE_TABLE, KEY_GROUP_TO_PHONE_GROUPID + "=" + rowId, null) > 0;
|
|
|
|
}
|
|
|
|
/**
|
|
* Return a Cursor over the list of all groups in the database
|
|
*
|
|
* @return Cursor over all groups
|
|
*/
|
|
public Cursor fetchAllGroups() {
|
|
|
|
return mDb.query(DATABASE_GROUP_TABLE, new String[] {KEY_GROUP_ROWID, KEY_GROUP_NAME}, null, null, null, null, KEY_GROUP_NAME);
|
|
}
|
|
|
|
/**
|
|
* Return a Cursor positioned at the group that matches the given rowId
|
|
*
|
|
* @param rowId id of group to retrieve
|
|
* @return Cursor positioned to matching group, if found
|
|
* @throws SQLException if group could not be found/retrieved
|
|
*/
|
|
public Cursor fetchGroup(long rowId) throws SQLException {
|
|
|
|
Cursor mCursor =
|
|
|
|
mDb.query(true, DATABASE_GROUP_TABLE, new String[] {KEY_GROUP_ROWID, KEY_GROUP_NAME}, KEY_GROUP_ROWID + "=" + rowId, null,
|
|
null, null, null, null);
|
|
if (mCursor != null) {
|
|
mCursor.moveToFirst();
|
|
}
|
|
return mCursor;
|
|
|
|
}
|
|
|
|
/**
|
|
* @param rowId id of group to update
|
|
* @param name value to set group name to
|
|
*/
|
|
public boolean updateGroup(long rowId, String name) {
|
|
ContentValues args = new ContentValues();
|
|
args.put(KEY_GROUP_NAME, name);
|
|
|
|
return mDb.update(DATABASE_GROUP_TABLE, args, KEY_GROUP_ROWID + "=" + rowId, null) > 0;
|
|
}
|
|
|
|
|
|
public Cursor fetchPhonesFromGroup(long groupId) {
|
|
Cursor mCursor = mDb.query(true, DATABASE_GROUP_TO_PHONE_TABLE, new String[] {KEY_GROUP_TO_PHONE_PHONEID}, KEY_GROUP_TO_PHONE_GROUPID + "=" + groupId, null, null, null, null, null);
|
|
Cursor userCursor = null;
|
|
int phoneIdIdx = mCursor.getColumnIndex(KEY_GROUP_TO_PHONE_PHONEID);
|
|
if(mCursor != null) {
|
|
userCursor = mCtx.getContentResolver().query(Phones.CONTENT_URI, null, "Phones."+ Phones._ID +" IN "+ cursorToStringList(mCursor, phoneIdIdx), null, Phones.NAME);
|
|
}
|
|
return userCursor;
|
|
}
|
|
|
|
public long addPhoneToGroup(long groupId, long phoneId ) {
|
|
ContentValues initialValues = new ContentValues();
|
|
initialValues.put(KEY_GROUP_TO_PHONE_GROUPID, groupId);
|
|
initialValues.put(KEY_GROUP_TO_PHONE_PHONEID, phoneId);
|
|
|
|
return mDb.insert(DATABASE_GROUP_TO_PHONE_TABLE, null, initialValues);
|
|
}
|
|
|
|
public boolean removePhoneToGroup(long groupId, long phoneId) {
|
|
return mDb.delete(DATABASE_GROUP_TO_PHONE_TABLE, KEY_GROUP_TO_PHONE_GROUPID + "=" + groupId+ " AND "+ KEY_GROUP_TO_PHONE_PHONEID + "=" + phoneId, null) > 0;
|
|
}
|
|
|
|
public String cursorToStringList(Cursor cursor, int columnIdx) {
|
|
cursor.moveToFirst();
|
|
String list = "( ";
|
|
while(!cursor.isAfterLast()) {
|
|
list += cursor.getString(columnIdx);
|
|
if(!cursor.isLast()) {
|
|
list += " , ";
|
|
}
|
|
cursor.moveToNext();
|
|
}
|
|
list +=" )";
|
|
return list;
|
|
}
|
|
}
|