1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
package it.niedermann.nextcloud.deck.remote.helpers.providers;
import androidx.annotation.Nullable;
import com.nextcloud.android.sso.api.EmptyResponse;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import it.niedermann.nextcloud.deck.DeckLog;
import it.niedermann.nextcloud.deck.database.DataBaseAdapter;
import it.niedermann.nextcloud.deck.model.interfaces.IRemoteEntity;
import it.niedermann.nextcloud.deck.remote.adapters.ServerAdapter;
import it.niedermann.nextcloud.deck.remote.api.ResponseCallback;
import it.niedermann.nextcloud.deck.remote.helpers.SyncHelper;
public abstract class AbstractSyncDataProvider<T extends IRemoteEntity> {
@Nullable
protected final AbstractSyncDataProvider<?> parent;
protected final List<AbstractSyncDataProvider<?>> children = new ArrayList<>();
protected boolean stillGoingDeeper = false;
public AbstractSyncDataProvider(@Nullable AbstractSyncDataProvider<?> parent) {
this.parent = parent;
}
public void registerChildInParent(AbstractSyncDataProvider<?> child) {
if (parent != null) {
parent.addChild(child);
}
}
public void handleDeletes(ServerAdapter serverAdapter, DataBaseAdapter dataBaseAdapter, long accountId, List<T> entitiesFromServer) {
// do nothing as a default.
}
/**
* Searches each entry of <code>listB</code> in list <code>listA</code> and returns the missing ones
*
* @param listA List
* @param listB List
* @return all entries of <code>listB</code> missing in <code>listA</code>
*/
public static <T extends IRemoteEntity> List<T> findDelta(List<T> listA, List<T> listB) {
List<T> delta = new ArrayList<>();
for (T b : listB) {
if (b == null) {
DeckLog.error("Entry in listB is null! skipping...");
continue;
}
boolean found = false;
for (T a : listA) {
if (a == null) {
DeckLog.error("Entry in listA is null! skipping...");
continue;
}
if ((a.getLocalId() != null && b.getLocalId() != null ? (a.getLocalId().equals(b.getLocalId()))
: a.getId().equals(b.getId())) && b.getAccountId() == a.getAccountId()) {
found = true;
break;
}
}
if (!found) {
delta.add(b);
}
}
return delta;
}
public void addChild(AbstractSyncDataProvider<?> child) {
children.add(child);
}
@SuppressWarnings("UnnecessaryReturnStatement")
public void getAllFromServer(ServerAdapter serverAdapter, long accountId, ResponseCallback<List<T>> responder, Instant lastSync) {
return;
}
public void getAllFromServer(ServerAdapter serverAdapter, DataBaseAdapter dataBaseAdapter, long accountId, ResponseCallback<List<T>> responder, Instant lastSync) {
// Overridden, because we also need the DB-Adapter at some points here (see ACL data provider)
getAllFromServer(serverAdapter, accountId, responder, lastSync);
}
public abstract T getSingleFromDB(DataBaseAdapter dataBaseAdapter, long accountId, T entity);
public abstract long createInDB(DataBaseAdapter dataBaseAdapter, long accountId, T b);
public void updateInDB(DataBaseAdapter dataBaseAdapter, long accountId, T t) {
updateInDB(dataBaseAdapter, accountId, t, true);
}
public abstract void updateInDB(DataBaseAdapter dataBaseAdapter, long accountId, T t, boolean setStatus);
public abstract void deleteInDB(DataBaseAdapter dataBaseAdapter, long accountId, T t);
public void deletePhysicallyInDB(DataBaseAdapter dataBaseAdapter, long accountId, T t) {
deleteInDB(dataBaseAdapter, accountId, t);
}
public void goDeeper(SyncHelper syncHelper, T existingEntity, T entityFromServer, ResponseCallback<Boolean> callback) {
childDone(this, callback, true);
}
public abstract void createOnServer(ServerAdapter serverAdapter, DataBaseAdapter dataBaseAdapter, long accountId, ResponseCallback<T> responder, T entity);
public abstract void updateOnServer(ServerAdapter serverAdapter, DataBaseAdapter dataBaseAdapter, long accountId, ResponseCallback<T> callback, T entity);
public abstract void deleteOnServer(ServerAdapter serverAdapter, long accountId, ResponseCallback<EmptyResponse> callback, T entity, DataBaseAdapter dataBaseAdapter);
public void childDone(AbstractSyncDataProvider<?> child, ResponseCallback<Boolean> responseCallback, boolean syncChangedSomething) {
removeChild(child);
if (!stillGoingDeeper && children.isEmpty()) {
if (parent != null) {
parent.childDone(this, responseCallback, syncChangedSomething);
} else {
responseCallback.onResponse(syncChangedSomething);
}
}
}
protected boolean removeChild(AbstractSyncDataProvider<?> child) {
return children.remove(child);
}
public void doneGoingDeeper(ResponseCallback<Boolean> responseCallback, boolean syncChangedSomething) {
stillGoingDeeper = false;
childDone(this, responseCallback, syncChangedSomething);
}
public void goingDeeper() {
stillGoingDeeper = true;
}
public abstract List<T> getAllChangedFromDB(DataBaseAdapter dataBaseAdapter, long accountId, Instant lastSync);
public void goDeeperForUpSync(SyncHelper syncHelper, ServerAdapter serverAdapter, DataBaseAdapter dataBaseAdapter, ResponseCallback<Boolean> callback) {
//do nothing
}
public void onError(ResponseCallback<Boolean> responseCallback) {
if (parent != null) {
parent.childDone(this, responseCallback, false);
}
}
public T applyUpdatesFromRemote(T localEntity, T remoteEntity, Long accountId) {
return remoteEntity;
}
}
|
