/** {@inheritDoc} */
public void onQueryComplete(int token, Object cookie, Cursor cursor) {
if (getActivity() == null || cursor == null) {
return;
}
mCursor = cursor;
getActivity().startManagingCursor(mCursor);
// If there was a last-opened track, load it. Otherwise load the first track.
cursor.moveToFirst();
String lastTrackID = UIUtils.getLastUsedTrackID(getActivity());
if (lastTrackID != null) {
while (!cursor.isAfterLast()) {
if (lastTrackID.equals(cursor.getString(TracksAdapter.TracksQuery.TRACK_ID))) {
break;
}
cursor.moveToNext();
}
if (cursor.isAfterLast()) {
loadTrack(null, mAutoloadTarget);
} else {
loadTrack(cursor, mAutoloadTarget);
}
} else {
loadTrack(null, mAutoloadTarget);
}
mAdapter.setHasAllItem(true);
mAdapter.setIsSessions(TracksFragment.NEXT_TYPE_SESSIONS.equals(mNextType));
mAdapter.changeCursor(mCursor);
}
private static void updateNotification(
Context context, MasterSecret masterSecret, boolean signal, int reminderCount) {
Cursor telcoCursor = null;
Cursor pushCursor = null;
try {
telcoCursor = DatabaseFactory.getMmsSmsDatabase(context).getUnread();
if ((telcoCursor == null || telcoCursor.isAfterLast())
&& (pushCursor == null || pushCursor.isAfterLast())) {
((NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE))
.cancel(NOTIFICATION_ID);
clearReminder(context);
return;
}
NotificationState notificationState =
constructNotificationState(context, masterSecret, telcoCursor);
if (notificationState.hasMultipleThreads()) {
sendMultipleThreadNotification(context, notificationState, signal);
} else {
sendSingleThreadNotification(context, masterSecret, notificationState, signal);
}
if (signal) {
scheduleReminder(context, reminderCount);
}
} finally {
if (telcoCursor != null) telcoCursor.close();
if (pushCursor != null) pushCursor.close();
}
}
private void combineBlockAgendas() {
final String filename = "agendas.org";
long agendaFileNodeID = db.getFileId(filename);
Cursor cursor = db.getNodeChildren(agendaFileNodeID);
cursor.moveToFirst();
String previousBlockTitle = "";
long previousBlockNode = -1;
while (cursor.isAfterLast() == false) {
String name = cursor.getString(cursor.getColumnIndex("name"));
if (name.indexOf(">") == -1) continue;
String blockTitle = name.substring(0, name.indexOf(">"));
if (TextUtils.isEmpty(blockTitle) == false) { // Is a block agenda
if (blockTitle.equals(previousBlockTitle)
== false) { // Create new node to contain block agenda
previousBlockNode =
db.addNode(agendaFileNodeID, blockTitle, "", "", "", db.getFilenameId(filename));
}
String blockEntryName = name.substring(name.indexOf(">") + 1);
long nodeId = cursor.getLong(cursor.getColumnIndex("_id"));
Cursor children = db.getNodeChildren(nodeId);
children.moveToFirst();
if (blockEntryName.startsWith("Day-agenda") && children.getCount() == 1) {
blockEntryName = children.getString(children.getColumnIndex("name"));
children = db.getNodeChildren(children.getLong(children.getColumnIndex("_id")));
children.moveToFirst();
cloneChildren(children, previousBlockNode, agendaFileNodeID, blockEntryName, filename);
} else if (blockEntryName.startsWith("Week-agenda")) {
while (children.isAfterLast() == false) {
blockEntryName = children.getString(children.getColumnIndex("name"));
Cursor children2 = db.getNodeChildren(children.getLong(children.getColumnIndex("_id")));
children2.moveToFirst();
cloneChildren(children2, previousBlockNode, agendaFileNodeID, blockEntryName, filename);
children2.close();
children.moveToNext();
}
} else
cloneChildren(children, previousBlockNode, agendaFileNodeID, blockEntryName, filename);
previousBlockTitle = blockTitle;
db.deleteNode(cursor.getLong(cursor.getColumnIndex("_id")));
children.close();
}
cursor.moveToNext();
}
cursor.close();
}
public List<Seance> cursorToSeance(Cursor res) {
List<Seance> listSeances = new ArrayList<Seance>();
res.moveToFirst();
while (res.isAfterLast() == false) {
Seance seance =
new Seance(
res.getInt(res.getColumnIndex(SEANCE_COLUMN_ID)),
res.getString(res.getColumnIndex(SEANCE_COLUMN_ACTUAL_DATE)),
res.getString(res.getColumnIndex(SEANCE_COLUMN_SHOW_TIME)),
res.getInt(res.getColumnIndex(SEANCE_COLUMN_IS_TROISD)) == 1,
res.getInt(res.getColumnIndex(SEANCE_COLUMN_IS_MALENTENDANT)) == 1,
res.getInt(res.getColumnIndex(SEANCE_COLUMN_IS_HANDICAPE)) == 1,
res.getString(res.getColumnIndex(SEANCE_COLUMN_NATIONALITY)),
res.getInt(res.getColumnIndex(SEANCE_COLUMN_CINEMAID)),
res.getInt(res.getColumnIndex(SEANCE_COLUMN_FILMID)),
res.getString(res.getColumnIndex(SEANCE_COLUMN_TITRE)),
res.getInt(res.getColumnIndex(SEANCE_COLUMN_CATEGORIEID)),
res.getInt(res.getColumnIndex(SEANCE_COLUMN_PERFORMANCEID)),
res.getString(res.getColumnIndex(SEANCE_COLUMN_CINEMA_SALLE)));
res.moveToNext();
listSeances.add(seance);
}
return listSeances;
}
public List<Event> cursorToEvent(Cursor res) {
List<Event> listEvents = new ArrayList<Event>();
res.moveToFirst();
while (res.isAfterLast() == false) {
List<Film> listFilms = stringToFilms(res.getString(res.getColumnIndex(EVENT_COLUMN_FILMS)));
Event event =
new Event(
res.getString(res.getColumnIndex(EVENT_COLUMN_ID)),
res.getString(res.getColumnIndex(EVENT_COLUMN_TITRE)),
res.getString(res.getColumnIndex(EVENT_COLUMN_SOUSTITRE)),
res.getString(res.getColumnIndex(EVENT_COLUMN_AFFICHE)),
res.getString(res.getColumnIndex(EVENT_COLUMN_DESCRIPTION)),
res.getString(res.getColumnIndex(EVENT_COLUMN_VAD_CONDITION)),
res.getString(res.getColumnIndex(EVENT_COLUMN_PARTENAIRE)),
res.getString(res.getColumnIndex(EVENT_COLUMN_DATE_DEB)),
res.getString(res.getColumnIndex(EVENT_COLUMN_DATE_FIN)),
res.getString(res.getColumnIndex(EVENT_COLUMN_HEURE)),
res.getString(res.getColumnIndex(EVENT_COLUMN_CONTACT)),
res.getString(res.getColumnIndex(EVENT_COLUMN_WEB_LABEL)),
res.getString(res.getColumnIndex(EVENT_COLUMN_EVENEMENTTYPEID)),
listFilms);
event.setTitre_wrapped(res.getString(res.getColumnIndex(EVENT_COLUMN_TITRE_WRAPPED)));
event.setType_wrapped(res.getString(res.getColumnIndex(EVENT_COLUMN_TYPE_WRAPPED)));
listEvents.add(event);
res.moveToNext();
}
return listEvents;
}
/**
* *
*
* @param db SQLiteDatabase - The database resource to query
* @return ArrayList<Price>
*/
public static ArrayList<Price> findAll(SQLiteDatabase db) {
String sql = "SELECT * FROM price ORDER BY created_at DESC";
Cursor cursor = db.rawQuery(sql, null);
ArrayList<Price> prices = new ArrayList<>();
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
int id = (cursor.getInt(cursor.getColumnIndex(PriceTable.COLUMN_NAME_ID)));
int stationId = (cursor.getInt(cursor.getColumnIndex(PriceTable.COLUMN_NAME_STATION_ID)));
int productClass =
(cursor.getInt(cursor.getColumnIndex(PriceTable.COLUMN_NAME_PRODUCT_CLASS)));
Double priceValue = (cursor.getDouble(cursor.getColumnIndex(PriceTable.COLUMN_NAME_PRICE)));
int verified = (cursor.getInt(cursor.getColumnIndex(PriceTable.COLUMN_NAME_VERIFIED)));
int createdAt = (cursor.getInt(cursor.getColumnIndex(PriceTable.COLUMN_NAME_CREATED_AT)));
String productName =
(cursor.getString(cursor.getColumnIndex(PriceTable.COLUMN_NAME_PRODUCT_NAME)));
Price price =
new Price(createdAt, id, priceValue, productClass, productName, stationId, verified);
prices.add(price);
cursor.moveToNext();
}
cursor.close();
return prices;
}
/**
* @param url the cached URL
* @return the cached result for the URL or null
*/
public CachedUrlResult getUrlResult(String url) {
Cursor cursor =
database.rawQuery(
"select "
+ DatabaseHelper.COLUMN_BODY
+ ", "
+ DatabaseHelper.COLUMN_DATETIME
+ " FROM "
+ DatabaseHelper.TABLE_URLS
+ " where "
+ DatabaseHelper.COLUMN_URL
+ " = ?",
new String[] {url});
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
String body = cursor.getString(0);
long dateTime = cursor.getInt(1);
return new UrlResultImpl(url, body, dateTime);
}
cursor.close();
// Didn't find the url
return null;
}
protected static List<Action> getAlarmActions(
SleepAsAndroidConstants.SLEEP_AS_ANDROID_ALARM_EVENT event) throws Exception {
ArrayList<Action> actions = new ArrayList<>();
String[] columns = {
SleepAsAndroidActionTable.COLUMN_ALARM_TYPE_ID, SleepAsAndroidActionTable.COLUMN_ACTION_ID
};
Cursor cursor =
DatabaseHandler.database.query(
SleepAsAndroidActionTable.TABLE_NAME,
columns,
SleepAsAndroidActionTable.COLUMN_ALARM_TYPE_ID + "==" + event.getId(),
null,
null,
null,
null);
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Long actionId = cursor.getLong(1);
actions.add(ActionHandler.get(actionId));
cursor.moveToNext();
}
cursor.close();
return actions;
}
/**
* Return a Cursor over the list of all todo in the database
*
* @return Cursor over all notes
*/
public List<BookInfo> fetchAllBooks() {
// createBook(new BookInfo("Agile Estimating and Planning", "Mike Cohn", "Paperback", "Book
// Description", 324, "2005-08-21", "Prentice Hall", "123455432"));
List<BookInfo> bookList = new ArrayList<BookInfo>();
Cursor results = database.query(DATABASE_TABLE, null, null, null, null, null, null);
results.moveToFirst();
while (!results.isAfterLast()) {
BookInfo thisBook = new BookInfo();
thisBook.setId(results.getInt(0));
thisBook.setTitle(results.getString(1));
thisBook.setAuthor(results.getString(2));
thisBook.setEdition(results.getString(3));
thisBook.setDescription(results.getString(4));
thisBook.setPages(new Integer(results.getString(5)));
thisBook.setReleaseDate(results.getString(6));
thisBook.setPublisher(results.getString(7));
thisBook.setIsbn(results.getString(8));
bookList.add(thisBook);
results.moveToNext();
}
results.close();
return bookList;
}
public ArrayList<Ingredient> getRecipeIngredients(String recipeName) {
Log.d(TAG, "getRecipeIngredients recipeName: " + recipeName);
SQLiteDatabase db = getReadableDatabase();
ArrayList<Ingredient> list = new ArrayList<>();
String statment =
"SELECT * FROM "
+ TABLE_INGREDIENTS
+ " WHERE "
+ ING_COL_RECIPE_NAME
+ "='"
+ recipeName
+ "';";
Cursor cursor = db.rawQuery(statment, null);
if (cursor.isAfterLast()) {
return null;
}
while (cursor.moveToNext()) {
Ingredient ingredient =
new Ingredient(
cursor.getDouble(2), Unit.returnUnitByInt(cursor.getInt(3)), cursor.getString(1));
list.add(ingredient);
}
return list;
}
private JSONArray constructResponse(Cursor c, String parameters) throws JSONException {
JSONObject params = new JSONObject(parameters);
c.moveToFirst();
String[] columnNames = c.getColumnNames();
JSONArray json = new JSONArray();
String addressFieldName = null;
if (params.has("addressFieldName") && null != params.getString("addressFieldName")) {
addressFieldName =
CaseFormat.LOWER_UNDERSCORE.to(
CaseFormat.LOWER_CAMEL, params.getString("addressFieldName"));
}
while ((!c.isAfterLast())) {
JSONObject obj = new JSONObject();
for (int i = 0; i < columnNames.length; i++) {
if (columnNames[i].equals("birthdate")) {
obj.put(
"age", Years.yearsBetween(DateTime.parse(c.getString(i)), new DateTime()).getYears());
} else if (params.has("addressFieldName") && columnNames[i].equals(addressFieldName)) {
JSONObject address = new JSONObject();
address.put(params.getString("addressFieldName"), c.getString(i));
obj.put("addressFieldValue", address);
} else if (params.has("extraIdentifiers") && columnNames[i].equals("extraIdentifiers")) {
JSONObject extraIdentifiers = new JSONObject();
extraIdentifiers.put("extraIdentifiers", c.getString(i));
obj.put("extraIdentifiers", extraIdentifiers);
} else {
obj.put(columnNames[i], c.getString(i));
}
}
json.put(obj);
c.moveToNext();
}
c.close();
return json;
}
public ArrayList<String> getBoughtProducts() {
database = getReadableDatabase();
ArrayList<String> productNames = new ArrayList<String>();
Cursor cursor =
database.rawQuery(
"SELECT "
+ PRODUCT_NAME
+ " FROM "
+ TABLE_PRODUCT
+ " AS P JOIN "
+ TABLE_BOUGHTPRODUCTS
+ " AS BP ON P."
+ PRODUCT_ID
+ "=BP."
+ BOUGHTPRODUCTS_PRODUCT
+ " ORDER BY BP."
+ BOUGHTPRODUCTS_TIMESTAMP
+ " DESC",
null);
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
String name = cursor.getString(0);
productNames.add(name);
cursor.moveToNext();
}
cursor.close();
database.close();
return productNames;
}
public ArrayList<AuctionItem> getAllAuctions() {
ArrayList<AuctionItem> allAuctions = new ArrayList<AuctionItem>();
SQLiteDatabase db = dbHelper.getReadableDatabase();
Cursor cursor = db.rawQuery("SELECT * FROM " + AUCTIONS_TABLE + ";", null);
if (cursor != null) {
if (cursor.moveToFirst()) {
while (cursor.isAfterLast() == false) {
AuctionItem auction = new AuctionItem();
auction.id = cursor.getInt(cursor.getColumnIndex("ID"));
auction.name = cursor.getString(cursor.getColumnIndex(AUCTIONS_NAME));
auction.starting_price =
Double.parseDouble(cursor.getString(cursor.getColumnIndex(AUCTIONS_STARTING_PRICE)));
auction.created_by = cursor.getString(cursor.getColumnIndex(AUCTIONS_CREATED_BY));
auction.highest_bid =
Double.parseDouble(cursor.getString(cursor.getColumnIndex(AUCTIONS_HIGHEST_BID)));
auction.highest_bidder = cursor.getString(cursor.getColumnIndex(AUCTIONS_HIGHEST_BIDDER));
auction.hours_active =
Integer.parseInt(cursor.getString(cursor.getColumnIndex(AUCTIONS_HOURS_ACTIVE)));
allAuctions.add(auction);
cursor.moveToNext();
}
}
cursor.close();
}
return allAuctions;
}
public List<String> getProductNames() {
database = this.getReadableDatabase();
ArrayList<String> names = new ArrayList<String>();
String[] columns = {SQLiteHelper.PRODUCT_NAME};
Cursor cursor =
database.query(
SQLiteHelper.TABLE_PRODUCT,
columns,
null,
null,
null,
null,
SQLiteHelper.PRODUCT_NAME + " ASC");
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
String name = cursor.getString(cursor.getColumnIndex(PRODUCT_NAME));
names.add(name);
cursor.moveToNext();
}
cursor.close();
database.close();
return names;
}
@Override
public ShoppingList getShoppingListFromDatabase() {
database = this.getReadableDatabase();
ShoppingList list = new ShoppingList();
Cursor cursor =
database.query(
SQLiteHelper.TABLE_SHOPPINGLIST,
null,
null,
null,
null,
null,
SQLiteHelper.SHOPPINGLIST_PRODUCT + " DESC");
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
int id = cursor.getInt(cursor.getColumnIndex(SHOPPINGLIST_PRODUCT));
Product p = getProductById(id);
if (p != null) {
list.addToList(p);
}
cursor.moveToNext();
}
cursor.close();
database.close();
return list;
}
public int countSamples() {
try {
synchronized (dbLock) {
if (db == null || !db.isOpen()) {
try {
db = helper.getWritableDatabase();
} catch (android.database.sqlite.SQLiteException ex) {
Log.e(TAG, "Could not open database", ex);
return -1;
}
}
Cursor cursor = db.rawQuery("select count(timestamp) FROM " + SAMPLES_VIRTUAL_TABLE, null);
if (cursor == null) {
// There are no results
return -1;
} else {
int ret = -1;
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
ret = cursor.getInt(0);
cursor.moveToNext();
}
cursor.close();
return ret;
}
}
} catch (Throwable th) {
Log.e(TAG, "Failed to query oldest samples!", th);
}
return -1;
}
public List<Sms> getAllSms() {
List<Sms> smsList = new ArrayList<Sms>();
Cursor cursor =
database.query(
MySQLiteHelper.TABLE_SMS,
allColumns,
null,
null,
null,
null,
MySQLiteHelper.COLUMN_SMS_ID + " DESC");
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Sms sms = cursorToSms(cursor);
smsList.add(sms);
cursor.moveToNext();
}
// make sure to close the cursor
cursor.close();
return smsList;
}
public Recipe getRecipe(String name) {
Log.d(TAG, "getRecipe Name: " + name);
SQLiteDatabase db = getReadableDatabase();
String statment =
"SELECT * FROM " + TABLE_RECIPES + " WHERE " + RECIPE_COL_NAME + "='" + name + "';";
Cursor cursor = db.rawQuery(statment, null);
if (cursor.isAfterLast()) {
return null;
}
cursor.moveToFirst();
Recipe recipe =
new Recipe(
name,
null,
cursor.getString(1),
cursor.getString(2),
BitmapUtils.StringToBitMap(cursor.getString(3)));
cursor.close();
ArrayList<Ingredient> list = getRecipeIngredients(name);
recipe.setIngredientList(list);
return recipe;
}
private String getNotes(String sortOrder) {
Uri uri = NoteTable.CONTENT_URI;
ContentResolver cr = getContentResolver();
String[] projection =
new String[] {
NoteTable._ID,
NoteTable.TITLE,
NoteTable.DESCRIPTION,
NoteTable.MODIFIED_DATE,
NoteTable.TYPE
};
Cursor c = cr.query(uri, projection, null, null, sortOrder);
int iId = c.getColumnIndex(NoteTable._ID);
int iTitle = c.getColumnIndex(NoteTable.TITLE);
int iDescription = c.getColumnIndex(NoteTable.DESCRIPTION);
int iType = c.getColumnIndex(NoteTable.TYPE);
JSONArray res = new JSONArray();
try {
for (c.moveToFirst(); !c.isAfterLast(); c.moveToNext()) {
JSONObject jsonObject = new JSONObject();
jsonObject.put(NoteTable._ID, c.getString(iId));
jsonObject.put(NoteTable.TITLE, c.getString(iTitle));
jsonObject.put(NoteTable.DESCRIPTION, c.getString(iDescription));
jsonObject.put(NoteTable.TYPE, c.getInt(iType));
res.put(jsonObject);
}
} catch (JSONException e) {
e.printStackTrace();
}
return res.toString();
}
@Override
public List<Device> getAllDevices() {
List<Device> devices = null;
try {
open();
devices = new ArrayList<Device>();
Cursor cursor = db.query(TABLE.ASSET.toString(), null, null, null, null, null, null);
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Device device = cursorToDevice(cursor);
devices.add(device);
cursor.moveToNext();
}
cursor.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
close();
}
return devices;
}
private boolean isCursorValid(Cursor cursor) {
// Check whether the cursor is valid or not.
if (cursor == null || cursor.isClosed() || cursor.isBeforeFirst() || cursor.isAfterLast()) {
return false;
}
return true;
}
private String getParentName(String parentGUID)
throws ParentNotFoundException, NullCursorException {
if (parentGUID == null) {
return "";
}
if (SPECIAL_GUIDS_MAP.containsKey(parentGUID)) {
return SPECIAL_GUIDS_MAP.get(parentGUID);
}
// Get parent name from database.
String parentName = "";
Cursor name = dataAccessor.fetch(new String[] {parentGUID});
try {
name.moveToFirst();
if (!name.isAfterLast()) {
parentName = RepoUtils.getStringFromCursor(name, BrowserContract.Bookmarks.TITLE);
} else {
Logger.error(
LOG_TAG,
"Couldn't find record with guid '" + parentGUID + "' when looking for parent name.");
throw new ParentNotFoundException(null);
}
} finally {
name.close();
}
return parentName;
}
public ArrayList<String> getNewsPaperNames() {
Cursor result;
ArrayList<String> newsPaperNames = new ArrayList<String>();
try {
db = appCtx.openOrCreateDatabase(databaseName, Context.MODE_PRIVATE, null);
result =
db.query(
true, tableName, new String[] {"NewsPaperName"}, null, null, null, null, null, null);
result.moveToFirst();
int newsPaperNameIndex = result.getColumnIndex("NewsPaperName");
while (!result.isAfterLast()) {
newsPaperNames.add(result.getString(newsPaperNameIndex));
result.moveToNext();
}
result.close();
db.close();
} catch (SQLiteException exception) {
Log.e("NewsPaperTableHandler::getNewsPaperNames", "Failed to get newspaper names");
} catch (Exception exception) {
Log.e("NewsPaperTableHandler::getNewsPaperNames", exception.getMessage());
}
return newsPaperNames;
}
private void sendResults(Long attemptId) {
dbHelper = new DbHelper(this);
Cursor cur = dbHelper.getUnsubmitted(attemptId.intValue());
cur.moveToFirst();
String content = "";
while (cur.isAfterLast() == false) {
content = dbHelper.createSubmitResponseObject(cur);
cur.moveToNext();
}
cur.close();
dbHelper.close();
APIRequest[] resultsToSend = new APIRequest[1];
APIRequest r = new APIRequest();
r.fullurl =
prefs.getString("prefServer", getString(R.string.prefServerDefault))
+ "api/?method=submit&format=json";
r.rowId = attemptId.intValue();
r.username = prefs.getString("prefUsername", "");
r.password = prefs.getString("prefPassword", "");
r.timeoutConnection = Integer.parseInt(prefs.getString("prefServerTimeoutConnection", "10000"));
r.timeoutSocket = Integer.parseInt(prefs.getString("prefServerTimeoutResponse", "10000"));
r.content = content;
resultsToSend[0] = r;
Toast.makeText(this, "Sending results", Toast.LENGTH_SHORT).show();
// send results to server
SubmitResultsTask task = new SubmitResultsTask(QuizActivityEnd.this);
task.setDownloaderListener(this);
task.execute(resultsToSend);
}
/**
* Method loads data from the bridges table
*
* @param db data base to read the data frim
*/
static void load(SQLiteDatabase db, Context context) {
assert (db != null);
assert (context != null);
Cursor cursor = db.rawQuery("select * from " + BridgeEntry.TABLE_NAME, null);
if (cursor.moveToFirst()) {
Bridge bridge;
while (!cursor.isAfterLast()) {
int id = cursor.getInt(cursor.getColumnIndex(BridgeEntry.COLUMN_NAME_BRIDGE_ID));
String userDefName =
cursor.getString(cursor.getColumnIndex(BridgeEntry.COLUMN_NAME_USER_DEF_NAME));
if (userDefName == null)
userDefName = context.getResources().getString(R.string.default_bridge);
bridge =
new Bridge(
id,
userDefName,
cursor.getString(cursor.getColumnIndex(BridgeEntry.COLUMN_NAME_FACTORY_NAME)));
DataManager.getInstance().addBridge(bridge);
if (cursor.getInt(cursor.getColumnIndex(BridgeEntry.COLUMN_NAME_ACTIVE)) == 1)
DataManager.getInstance().setActiveBridgeId(id);
cursor.moveToNext();
}
cursor.close();
}
}
/**
* Gets a sequence of API calls from the queue for the given endpoint. Does not remove items from
* queue.
*
* @param writeKey The writeKey to peek for queued calls for.
* @param endPoint The type of api call to get a batch for (based on end point).
*/
public Vector<QueuedApiCall> getBatch(String writeKey, String endPoint) {
Cursor cursor =
getWritableDatabase()
.query(
TABLE_QUEUE, /* All columns */
null,
"write_key = ?",
new String[] {writeKey},
null,
null,
/* ORDER BY */ "id ASC", /* LIMIT */
"100");
Vector<QueuedApiCall> batch = new Vector<QueuedApiCall>();
if (cursor != null && cursor.moveToFirst()) {
while (!cursor.isAfterLast()) {
String callEndPoint = cursor.getString(cursor.getColumnIndex("endpoint"));
if (!callEndPoint.equalsIgnoreCase(endPoint)) {
break; // Different type, stop batch
}
batch.add(
new QueuedApiCall(
cursor.getLong(cursor.getColumnIndex("id")),
cursor.getString(cursor.getColumnIndex("endpoint")),
cursor.getString(cursor.getColumnIndex("payload")),
cursor.getString(cursor.getColumnIndex("write_key"))));
cursor.moveToNext();
}
}
cursor.close();
return batch;
}
/**
* Fetches the full list of Posts stored in the local Database
*
* @param context
* @return
*/
public static List<Post> getPosts(Context context) {
DatabaseWrapper databaseWrapper = new DatabaseWrapper(context);
SQLiteDatabase database = databaseWrapper.getReadableDatabase();
List<Post> postList = null;
if (database != null) {
Cursor cursor = database.rawQuery("SELECT * FROM " + PostORM.TABLE_NAME, null);
Log.i(TAG, "Loaded " + cursor.getCount() + " Posts...");
if (cursor.getCount() > 0) {
postList = new ArrayList<Post>();
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Post post = cursorToPost(cursor);
post.setTags(TagORM.getTagsForPost(context, post));
postList.add(post);
cursor.moveToNext();
}
Log.i(TAG, "Posts loaded successfully.");
}
database.close();
}
return postList;
}
public List<CachedUrlResult> getAll() {
List<CachedUrlResult> urlResults = new ArrayList<CachedUrlResult>();
Cursor cursor =
database.rawQuery(
"select "
+ DatabaseHelper.COLUMN_URL
+ ", "
+ DatabaseHelper.COLUMN_BODY
+ ", "
+ DatabaseHelper.COLUMN_DATETIME
+ " FROM "
+ DatabaseHelper.TABLE_URLS
+ " where 1",
new String[] {});
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
String body = cursor.getString(0);
String url = cursor.getString(1);
long dateTime = cursor.getInt(2);
urlResults.add(new UrlResultImpl(url, body, dateTime));
}
cursor.close();
return urlResults;
}
@MediumTest
public void testCursor2() throws Exception {
populateDefaultTable();
Cursor c = mDatabase.query("test", null, "_id > 1000", null, null, null, null);
assertEquals(0, c.getCount());
assertTrue(c.isBeforeFirst());
try {
c.getInt(0);
fail("CursorIndexOutOfBoundsException expected");
} catch (CursorIndexOutOfBoundsException ex) {
// expected
}
int i;
for (c.moveToFirst(), i = 0; !c.isAfterLast(); c.moveToNext(), i++) {
c.getInt(0);
}
assertEquals(0, i);
try {
c.getInt(0);
fail("CursorIndexOutOfBoundsException expected");
} catch (CursorIndexOutOfBoundsException ex) {
// expected
}
c.close();
}
public boolean checkMissingTomesIcons(Handler handler) {
Tome tome;
Log.d(Global.getLogTag(MyDbAdaptor.class), "checkMissingTomesIcons");
Cursor cursor =
database.rawQuery(MySQLiteOpenHelper.SELECT_ALL_MISSING_WITHOUT_ICON_RQST, null);
if (cursor.moveToFirst()) {
while (!cursor.isAfterLast()) {
tome = new Tome();
tome.isMissingTome = true;
tome.setId(cursor.getInt(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_ID)));
tome.setNumber(cursor.getInt(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_NUMBER)));
tome.setSerieId(
cursor.getInt(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_SERIE_ID)));
tome.setTomePageUrl(
cursor.getString(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_PAGEURL)));
tome.setIconUrl(
cursor.getString(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_ICONURL)));
tome.setIcon(cursor.getBlob(cursor.getColumnIndex(MySQLiteOpenHelper.COL_MISSING_ICON)));
ServerConnector.getMissingTomeIcon(handler, tome);
cursor.moveToNext();
}
}
cursor.close();
return true;
}
