/** * Waits until all enqueued operations are complete, but at most the given amount of milliseconds. If the thread * gets interrupted, any {@link InterruptedException} will be rethrown as a {@link DaoException}. * * @return true if operations completed in the given time frame. */ public boolean waitForCompletion(int maxMillis) { return executor.waitForCompletion(maxMillis); }
/** * @return true if this operation is mergeable with the given operation. Checks for null, {@link #FLAG_MERGE_TX}, * and if the database instances match. */ boolean isMergeableWith(AsyncOperation other) { return other != null && isMergeTx() && other.isMergeTx() && getDatabase() == other.getDatabase(); }
/** * Creates a new {@link AsyncSession} to issue asynchronous entity operations. See {@link AsyncSession} for details. */ public AsyncSession startAsyncSession() { return new AsyncSession(this); }
private AsyncOperation enqueueDatabaseOperation(OperationType type, Object param, int flags) { Database database = daoSession.getDatabase(); AsyncOperation operation = new AsyncOperation(type, null, database, param, flags | sessionFlags); executor.enqueue(operation); return operation; }
private void executeOperationAndPostCompleted(AsyncOperation operation) { executeOperation(operation); handleOperationCompleted(operation); }
/** Asynchronous version of {@link AbstractDao#insertOrReplace(Object)}. */ public AsyncOperation insertOrReplace(Object entity) { return insertOrReplace(entity, 0); }
/** Asynchronous version of {@link AbstractDao#update(Object)}. */ public AsyncOperation update(Object entity) { return update(entity, 0); }
/** Asynchronous version of {@link AbstractDao#insertOrReplaceInTx(Object...)}. */ public <E> AsyncOperation insertOrReplaceInTx(Class<E> entityClass, E... entities) { return insertOrReplaceInTx(entityClass, 0, entities); }
/** Asynchronous version of {@link Query#unique()}. */ public AsyncOperation queryUnique(Query<?> query, int flags) { return enqueueDatabaseOperation(OperationType.QueryUnique, query, flags); }
@Override public boolean handleMessage(Message msg) { AsyncOperationListener listenerToCall = listenerMainThread; if (listenerToCall != null) { listenerToCall.onAsyncOperationCompleted((AsyncOperation) msg.obj); } return false; }
/** Asynchronous version of {@link AbstractDao#insertInTx(Object...)}. */ public <E> AsyncOperation insertInTx(Class<E> entityClass, int flags, E... entities) { return enqueEntityOperation(OperationType.InsertInTxArray, entityClass, entities, flags); }
/** Asynchronous version of {@link AbstractDao#updateInTx(Iterable)}. */ public <E> AsyncOperation updateInTx(Class<E> entityClass, Iterable<E> entities) { return updateInTx(entityClass, entities, 0); }
/** Asynchronous version of {@link AbstractDao#delete(Object)}. */ public AsyncOperation delete(Object entity) { return delete(entity, 0); }
/** Asynchronous version of {@link AbstractDao#deleteInTx(Object...)}. */ public <E> AsyncOperation deleteInTx(Class<E> entityClass, E... entities) { return deleteInTx(entityClass, 0, entities); }
/** Asynchronous version of {@link AbstractDao#insertInTx(Object...)}. */ public <E> AsyncOperation insertInTx(Class<E> entityClass, E... entities) { return insertInTx(entityClass, 0, entities); }
/** Asynchronous version of {@link AbstractDao#refresh(Object)}. */ public AsyncOperation refresh(Object entity) { return refresh(entity, 0); }
private <E> AsyncOperation enqueEntityOperation(OperationType type, Class<E> entityClass, Object param, int flags) { AbstractDao<?, ?> dao = daoSession.getDao(entityClass); AsyncOperation operation = new AsyncOperation(type, dao, null, param, flags | sessionFlags); executor.enqueue(operation); return operation; }
/** * Waits until all enqueued operations are complete. If the thread gets interrupted, any * {@link InterruptedException} will be rethrown as a {@link DaoException}. */ public void waitForCompletion() { executor.waitForCompletion(); }
/** Asynchronous version of {@link AbstractDao#insertOrReplaceInTx(Iterable)}. */ public <E> AsyncOperation insertOrReplaceInTx(Class<E> entityClass, Iterable<E> entities) { return insertOrReplaceInTx(entityClass, entities, 0); }
/** Asynchronous version of {@link Query#list()}. */ public AsyncOperation queryList(Query<?> query, int flags) { return enqueueDatabaseOperation(OperationType.QueryList, query, flags); }