com.raizlabs.android.dbflow.structure.BaseModel Java Examples

/**
 * @see #update(Object, DatabaseWrapper, DatabaseStatement)
 */
@Deprecated
@SuppressWarnings("unchecked")
public synchronized boolean update(@NonNull TModel model,
                                   @NonNull DatabaseWrapper wrapper,
                                   @NonNull ContentValues contentValues) {
    modelAdapter.saveForeignKeys(model, wrapper);
    modelAdapter.bindToContentValues(contentValues, model);
    boolean successful = wrapper.updateWithOnConflict(modelAdapter.getTableName(), contentValues,
        modelAdapter.getPrimaryConditionClause(model).getQuery(), null,
        ConflictAction.getSQLiteDatabaseAlgorithmInt(modelAdapter.getUpdateOnConflictAction())) != 0;
    if (successful) {
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE);
    }
    return successful;
}
 

/**
 * Legacy save method. Uses {@link ContentValues} vs. the faster {@link DatabaseStatement} for updates.
 *
 * @see #save(Object, DatabaseWrapper, DatabaseStatement, DatabaseStatement)
 */
@Deprecated
@SuppressWarnings({"unchecked", "deprecation"})
public synchronized boolean save(@NonNull TModel model,
                                 @NonNull DatabaseWrapper wrapper,
                                 @NonNull DatabaseStatement insertStatement,
                                 @NonNull ContentValues contentValues) {
    boolean exists = modelAdapter.exists(model, wrapper);

    if (exists) {
        exists = update(model, wrapper, contentValues);
    }

    if (!exists) {
        exists = insert(model, insertStatement, wrapper) > INSERT_FAILED;
    }

    if (exists) {
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE);
    }

    // return successful store into db.
    return exists;
}
 

@SuppressWarnings("unchecked")
public synchronized boolean save(@NonNull TModel model,
                                 @NonNull DatabaseWrapper wrapper,
                                 @NonNull DatabaseStatement insertStatement,
                                 @NonNull DatabaseStatement updateStatement) {
    boolean exists = modelAdapter.exists(model, wrapper);

    if (exists) {
        exists = update(model, wrapper, updateStatement);
    }

    if (!exists) {
        exists = insert(model, insertStatement, wrapper) > INSERT_FAILED;
    }

    if (exists) {
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.SAVE);
    }

    // return successful store into db.
    return exists;
}
 

@SuppressWarnings("unchecked")
public synchronized long insert(@NonNull TModel model,
                                @NonNull DatabaseStatement insertStatement,
                                @NonNull DatabaseWrapper wrapper) {
    modelAdapter.saveForeignKeys(model, wrapper);
    modelAdapter.bindToInsertStatement(insertStatement, model);
    long id = insertStatement.executeInsert();
    if (id > INSERT_FAILED) {
        modelAdapter.updateAutoIncrement(model, id);
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.INSERT);
    }
    return id;
}
 

public TrackedTable(Class<? extends Model> trackedModel) {
    this(trackedModel, Arrays.asList(
            BaseModel.Action.INSERT,
            BaseModel.Action.UPDATE,
            BaseModel.Action.DELETE,
            BaseModel.Action.SAVE));
}
 

@Override
public void onModelStateChanged(Class<? extends Model> aClass, BaseModel.Action action) {
    Log.d(TAG, "onModelStateChanged() " + aClass.getSimpleName() + ": " + action);

    if (notifyLoader(action)) {
        mLoader.onContentChanged();
    }
}
 

private boolean notifyLoader(BaseModel.Action action) {
    if (mTrackedTable.getActions().isEmpty()) {
        return true;
    }

    for (BaseModel.Action modelAction : mTrackedTable.getActions()) {
        if (modelAction.equals(action)) {
            return true;
        }
    }

    return false;
}
 

@SuppressWarnings("unchecked")
public synchronized boolean delete(@NonNull TModel model,
                                   @NonNull DatabaseStatement deleteStatement,
                                   @NonNull DatabaseWrapper wrapper) {
    modelAdapter.deleteForeignKeys(model, wrapper);
    modelAdapter.bindToDeleteStatement(deleteStatement, model);

    boolean success = deleteStatement.executeUpdateDelete() != 0;
    if (success) {
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.DELETE);
    }
    modelAdapter.updateAutoIncrement(model, 0);
    return success;
}
 

@SuppressWarnings("unchecked")
public synchronized boolean update(@NonNull TModel model, @NonNull DatabaseWrapper wrapper,
                                   @NonNull DatabaseStatement databaseStatement) {
    modelAdapter.saveForeignKeys(model, wrapper);
    modelAdapter.bindToUpdateStatement(databaseStatement, model);
    boolean successful = databaseStatement.executeUpdateDelete() != 0;
    if (successful) {
        NotifyDistributor.get().notifyModelChanged(model, modelAdapter, BaseModel.Action.UPDATE);
    }
    return successful;
}
 

@Override
public <T> void notifyTableChanged(@NonNull Class<T> table, @NonNull BaseModel.Action action) {
    if (FlowContentObserver.shouldNotify()) {
        FlowManager.getContext().getContentResolver()
            .notifyChange(SqlUtils.getNotificationUri(table, action, (SQLOperator[]) null), null, true);
    }
}
 

@Override
public Loader<Boolean> onCreateLoader(int i, Bundle bundle) {
    List<BaseModel.Action> actionsToTrack = Arrays.asList(
            BaseModel.Action.INSERT, BaseModel.Action.DELETE);
    List<DbLoader.TrackedTable> trackedTables = Arrays.asList(
            new DbLoader.TrackedTable(Interpretation.class, actionsToTrack));
    return new DbLoader<>(getActivity().getApplicationContext(),
            trackedTables, new InterpretationsQuery());
}
 

@Override
public <T> void notifyTableChanged(@NonNull Class<T> table, @NonNull BaseModel.Action action) {
    final Set<OnTableChangedListener> listeners = tableChangedListenerMap.get(table);
    if (listeners != null) {
        for (OnTableChangedListener listener : listeners) {
            if (listener != null) {
                listener.onTableChanged(table, action);
            }
        }
    }
}
 

@Override
public <T> void notifyModelChanged(@NonNull T model, @NonNull ModelAdapter<T> adapter,
                                   @NonNull BaseModel.Action action) {
    final Set<OnModelStateChangedListener> listeners = modelChangedListenerMap.get(adapter.getModelClass());
    if (listeners != null) {
        for (OnModelStateChangedListener listener : listeners) {
            if (listener != null) {
                listener.onModelChanged(model, action);
            }
        }
    }
}
 

@Override
public Loader<Boolean> onCreateLoader(int id, Bundle args) {
    List<BaseModel.Action> actionsToTrack = Arrays.asList(
            BaseModel.Action.INSERT, BaseModel.Action.DELETE);
    List<DbLoader.TrackedTable> trackedTables = Arrays.asList(
            new DbLoader.TrackedTable(Dashboard.class, actionsToTrack));
    return new DbLoader<>(getActivity().getApplicationContext(),
            trackedTables, new DashboardsQuery());
}
 

@Override
public <TModel> void notifyModelChanged(@NonNull TModel model,
                                        @NonNull ModelAdapter<TModel> adapter,
                                        @NonNull BaseModel.Action action) {
    FlowManager.getModelNotifierForTable(adapter.getModelClass())
        .notifyModelChanged(model, adapter, action);
}
 

@Override
public <T> void notifyModelChanged(@NonNull T model, @NonNull ModelAdapter<T> adapter,
                                   @NonNull BaseModel.Action action) {
    if (FlowContentObserver.shouldNotify()) {
        FlowManager.getContext().getContentResolver()
            .notifyChange(SqlUtils.getNotificationUri(adapter.getModelClass(), action,
                adapter.getPrimaryConditionClause(model).getConditions()), null, true);
    }
}
 

@Override
public Loader<List<InterpretationComment>> onCreateLoader(int id, Bundle args) {
    if (LOADER_ID == id) {
        List<TrackedTable> trackedTables = Arrays.asList(
                new TrackedTable(InterpretationComment.class, BaseModel.Action.UPDATE));
        return new DbLoader<>(getActivity().getApplicationContext(),
                trackedTables, new CommentsQuery(args.getLong(INTERPRETATION_ID)));
    }
    return null;
}
 

public static <T extends BaseModel> DbOperation update(T model) {
    return new DbOperation(BaseModel.Action.UPDATE, model);
}
 

public TrackedTable(Class<? extends Model> trackedModel,
                    BaseModel.Action action) {
    this(trackedModel, Arrays.asList(action));
}
 

public TrackedTable(Class<? extends Model> trackedModel,
                    List<BaseModel.Action> actions) {
    mTrackedModel = trackedModel;
    mActions = actions;
}
 

public List<BaseModel.Action> getActions() {
    return mActions;
}
 

private DbOperation(BaseModel.Action action, BaseModel model) {
    mModel = isNull(model, "BaseModel object must nto be null,");
    mAction = isNull(action, "BaseModel.Action object must not be null");
}
 

public static <T extends BaseModel> DbOperation insert(T model) {
    return new DbOperation(BaseModel.Action.INSERT, model);
}
 

public static <T extends BaseModel> DbOperation save(T model) {
    return new DbOperation(BaseModel.Action.SAVE, model);
}
 

@NonNull
@Override
public BaseModel.Action getPrimaryAction() {
    return whereBase.getPrimaryAction();
}
 

public BaseModel.Action getAction() {
    return mAction;
}
 

public BaseModel getModel() {
    return mModel;
}
 

public static <T extends BaseModel> DbOperation delete(T model) {
    return new DbOperation(BaseModel.Action.DELETE, model);
}
 

public static GsonBuilder getRspGsonBuilder() {
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.setExclusionStrategies(new SpecificClassExclusionStrategy(null, BaseModel.class));
    gsonBuilder.setDateFormat("yyyy-MM-dd'T'HH:mm:ss");
    return gsonBuilder;
}
 

/**
 * Notifies listeners of table-level changes from the SQLite-wrapper language.
 */
@Override
public <TModel> void notifyTableChanged(@NonNull Class<TModel> table,
                                        @NonNull BaseModel.Action action) {
    FlowManager.getModelNotifierForTable(table).notifyTableChanged(table, action);
}