下面列出了io.reactivex.functions.Cancellable#com.google.firebase.database.DataSnapshot 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public void setLikeBtn(final String post_key) {
mDatabaseLike.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
if (dataSnapshot.child(post_key).hasChild(mAuth.getCurrentUser().getUid())) {
mLikebtn.setImageResource(R.drawable.ic_yes_heart_colored);
} else {
mLikebtn.setImageResource(R.drawable.ic_no_heart_gray);
}
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
public void updateServices(){
databaseServices.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
services.clear(); // might need to remove
for(DataSnapshot postSnapshot : dataSnapshot.getChildren()){
DataBaseService service = postSnapshot.getValue(DataBaseService.class);
services.add(service);
}
}
@Override
public void onCancelled(@NonNull DatabaseError databaseError) {
}
});
}
@NonNull
public static Observable<DataSnapshot> observeSingleValueEvent(@NonNull final Query query) {
return Observable.unsafeCreate(new Observable.OnSubscribe<DataSnapshot>() {
@Override
public void call(final Subscriber<? super DataSnapshot> subscriber) {
query.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(dataSnapshot);
subscriber.onCompleted();
}
}
@Override
public void onCancelled(DatabaseError error) {
if (!subscriber.isUnsubscribed()) {
subscriber.onError(new RxFirebaseDataException(error));
}
}
});
}
});
}
@Test
public void testData_DataReference() {
TestObserver<DataSnapshot> sub = TestObserver.create();
RxFirebaseDatabase.data(mockDatabaseReference)
.subscribe(sub);
verifyDataReferenceAddListenerForSingleValueEvent();
callValueEventOnDataChange("Foo");
sub.dispose();
// Ensure no more values are emitted after unsubscribe
callValueEventOnDataChange("Foo");
sub.assertNoErrors();
sub.assertComplete();
sub.assertValueCount(1);
}
private void getHistory(){
riderHistory.child(Common.userID).addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
for(DataSnapshot postSnapshot: dataSnapshot.getChildren()){
History history = postSnapshot.getValue(History.class);
listData.add(history);
}
adapter.notifyDataSetChanged();
}
@Override
public void onCancelled(@NonNull DatabaseError databaseError) {
}
});
}
@Test
public void testAttachingListener() {
DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);
ValueEventListener listener = ref.limitToLast(1)
.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot snapshot) {
// No-op
}
@Override
public void onCancelled(DatabaseError error) {
}
});
assertNotNull(listener);
}
@Test
public void testData_DataReference() {
TestObserver<DataSnapshot> sub = TestObserver.create();
RxDatabaseReference.single(mockDatabaseReference)
.subscribe(sub);
verifyDataReferenceAddListenerForSingleValueEvent();
callValueEventOnDataChange("Foo");
sub.dispose();
// Ensure no more values are emitted after unsubscribe
callValueEventOnDataChange("Foo");
sub.assertNoErrors();
sub.assertComplete();
sub.assertValueCount(1);
}
/**
* Fetch order by order address key
* @param key
* @return Order
*/
public static Observable<Order> fetchOrderByKey(String key) {
return Observable.create(subscriber -> {
FirebaseDatabase.getInstance().getReference(Constants.Path.ORDERS).child(key).addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
try {
Order order = dataSnapshot.getValue(Order.class);
subscriber.onNext(order);
subscriber.onCompleted();
} catch (Exception e) {
Timber.e(e, "Order retrival by key failed, key: %s", key);
subscriber.onError(e);
}
}
@Override
public void onCancelled(DatabaseError databaseError) {
Timber.e(databaseError.toException(), "Order retrival by key failed, key: %s", key);
subscriber.onError(databaseError.toException());
}
});
});
}
public <T> Observable<T> push(final DatabaseReference databaseReference) {
final Observable<T> observable = Observable.create(new Observable.OnSubscribe<T>() {
@Override
public void call(final Subscriber<? super T> subscriber) {
databaseReference.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
subscriber.onNext(null);
subscriber.onCompleted();
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
});
databaseReference.push();
return observable;
}
@SuppressWarnings("unchecked")
static List resolve(DataSnapshot dataSnapshot) {
if (dataSnapshot.getValue() == null) {
throw new IllegalStateException();
}
List result = new ArrayList<>();
Iterable<DataSnapshot> dataSnapshots;
if (ClassReflection.isAssignableFrom(Map.class, dataSnapshot.getValue().getClass())) {
dataSnapshots = ((Map) dataSnapshot.getValue()).values();
} else {
dataSnapshots = dataSnapshot.getChildren();
}
for (Object o : dataSnapshots) {
if (o instanceof DataSnapshot) {
result.add(((DataSnapshot) o).getValue());
} else {
result.add(o);
}
}
return result;
}
private void listenForData() {
DatabaseReference receiveDB = FirebaseDatabase.getInstance().getReference().child("users")
.child(FirebaseAuth.getInstance().getUid()).child("received");
receiveDB.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
if (dataSnapshot.exists()) {
for (DataSnapshot snap : dataSnapshot.getChildren()) {
getUserInfo(snap.getKey());
}
}
}
@Override
public void onCancelled(@NonNull DatabaseError databaseError) {
}
});
}
public static AgendaSection toAgendaSection(final DataSnapshot data) {
final AgendaSection section = new AgendaSection();
populateSection(data, section);
Map<String, AgendaItem> items = data.child("items").getValue(new GenericTypeIndicator<Map<String, AgendaItem>>() {});
if (items == null) {
items = Collections.emptyMap();
}
// Force empty speaker list when null so the client doesn't have to
// always check null.
for (final Map.Entry<String, AgendaItem> entry : items.entrySet()) {
if (entry.getValue().getSpeakerIds() == null) {
entry.getValue().setSpeakerIds(Collections.<String>emptyList());
}
}
section.setItems(items);
return section;
}
public void getFollowingPosts(String userId, OnDataChangedListener<FollowingPost> listener) {
databaseHelper
.getDatabaseReference()
.child(DatabaseHelper.FOLLOWINGS_POSTS_DB_KEY)
.child(userId)
.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
List<FollowingPost> list = new ArrayList<>();
for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
FollowingPost followingPost = snapshot.getValue(FollowingPost.class);
list.add(followingPost);
}
Collections.reverse(list);
listener.onListChanged(list);
}
@Override
public void onCancelled(DatabaseError databaseError) {
LogUtil.logDebug(TAG, "getFollowingPosts, onCancelled");
}
});
}
public static void setbio(final TextView bio){
FirebaseAuth auth=FirebaseAuth.getInstance();
FirebaseUser user=auth.getCurrentUser();
FirebaseDatabase database = FirebaseDatabase.getInstance();
if (user !=null){
DatabaseReference myRef = database.getReference("users").child(user.getUid()).child("user_bio");
myRef.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
if (dataSnapshot.exists()){
bio.setText(dataSnapshot.getValue(String.class));
}
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
}
private void warmEvent() {
final DatabaseReference eventRef = fdb.getReference("/event");
eventRef.addValueEventListener(new ExecutorValueEventListener(executor) {
@Override
protected void onDataChangeExecutor(DataSnapshot data) {
LOGGER.fine("New Event data");
event = FirebaseDatabaseHelpers.toEvent(data);
bus.post(event);
}
@Override
protected void onCancelledExecutor(DatabaseError databaseError) {
LOGGER.log(Level.SEVERE, "Error reading event", databaseError.toException());
}
});
}
public void getDatabaseProductData() {
mDatabase = FirebaseDatabase.getInstance().getReference().child("Product");
mDatabase.keepSynced(true);
mDatabase.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
for (DataSnapshot ds : dataSnapshot.getChildren()) {
if (ds.getKey().equals(selectedFoundationID) || ds.getKey().equals(selectedBrushID) || ds.getKey().equals(selectedEyeshadowID) || ds.getKey().equals(selectedLipstickID)) {
ProductTypeTwo result = ds.getValue(ProductTypeTwo.class);
mAppliedProducts.put(ds.getKey(), result);
Log.d(" product key ", ds.getKey());
}
}
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
/********************************* Data Querying Methods *************************/
//Load friends from firebase
public void getFirebaseFriend() {
/******************** Getting Friends From Firebase *************/
String ref = "Friends/" + getActivity().getSharedPreferences("user_credentials", 0).getString("Name", null);
Log.d(TAG, "Firebase Reference :" + ref);
DatabaseReference friends = FirebaseDatabase.getInstance().getReference(ref);
friends.keepSynced(true);
friends.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
for (DataSnapshot k : dataSnapshot.getChildren()) {
friend_list.add(k.getKey());
Log.d(TAG, "Debug Firebase data query" + k.getValue().toString());
}
Log.d(TAG, String.format("The Friend List Size is %d",friend_list.size()));
getFirstFriendProfile();
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
public void registerByGoogleAccount(final GoogleSignInAccount account){
final User user=new User();
users.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
User post = dataSnapshot.child(account.getId()).getValue(User.class);
if(post==null) showRegisterPhone(user, account);
else loginSuccess();
}
@Override
public void onCancelled(@NonNull DatabaseError databaseError) {
}
});
}
private void checkUserExist() {
if (mAuth.getCurrentUser() != null) {
final String user_id = mAuth.getCurrentUser().getUid();
mDatabaseUsers.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
if (!dataSnapshot.hasChild(user_id)) {
Intent mainIntent = new Intent(getActivity(), ProfileEditActivity.class);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(mainIntent);
}
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
}
}
public final void getCheckInByEmail(final String _email, final OnLoadCallback<CheckIn> loadCallback) {
mDatabaseCheckIn.orderByChild("email").equalTo(_email).addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
long count = dataSnapshot.getChildrenCount();
Log.d(TAG, TABLE_CHECK_IN + " | MyCheckIns | Count is: " + count);
final List<CheckIn> checkIns = new ArrayList<CheckIn>();
for (final DataSnapshot dataSnapshot1 : dataSnapshot.getChildren()) {
final CheckIn checkIn = dataSnapshot1.getValue(CheckIn.class);
checkIns.add(checkIn);
Log.d(TAG, TABLE_CHECK_IN + " | MyCheckIns | Value " + checkIn.checkInMessage);
}
loadCallback.onDataChange(checkIns);
}
@Override
public void onCancelled(DatabaseError databaseError) {
Log.d(TAG, TABLE_CHECK_IN + " | MyCheckIns | Failed to read: ", databaseError.toException());
loadCallback.onCancelled();
}
});
}
public void getFollowersList(String targetUserId, OnDataChangedListener<String> onDataChangedListener) {
getFollowersRef(targetUserId).addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
List<String> list = new ArrayList<>();
for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
Follower follower = snapshot.getValue(Follower.class);
if (follower != null) {
String profileId = follower.getProfileId();
list.add(profileId);
}
}
onDataChangedListener.onListChanged(list);
}
@Override
public void onCancelled(DatabaseError databaseError) {
LogUtil.logDebug(TAG, "getFollowersList, onCancelled");
}
});
}
public static void SetDOB(final AppCompatActivity a) {
FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
if (user != null) {
DatabaseReference db = FirebaseDatabase.getInstance().getReference()
.child("Users").child(user.getUid().toString()).child("dob");
db.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
TextView bal = (TextView)a.findViewById(R.id.dobfield);
bal.setText("Date of Birth: " + dataSnapshot.getValue());
}
@Override
public void onCancelled(DatabaseError databaseError) {
// ...
}
});
}
}
private void displayLocation(){
if (currentLat!=null && currentLng!=null){
//presence system
driversAvailable = FirebaseDatabase.getInstance().getReference(Common.driver_tbl);
driversAvailable.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
//if have change from drivers table, we will reload all drivers available
loadAllAvailableDriver(new LatLng(currentLat, currentLng));
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
loadAllAvailableDriver(new LatLng(currentLat, currentLng));
}else{
Message.messageError(this, Errors.WITHOUT_LOCATION);
}
}
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
for (DataSnapshot snapshot : dataSnapshot.getChildren()) {
productBasket = new ProductBasket();
productBasket.setPiece(snapshot.getValue(ProductBasket.class).getPiece());
productBasket.setProductId(snapshot.getValue(ProductBasket.class).getProductId());
productBaskets.add(productBasket);
}
try {
Toast.makeText(getActivity(), productBaskets.size()+"", Toast.LENGTH_SHORT).show();
}catch (Exception e){
}
}
public static void SetUsername(final AppCompatActivity a) {
FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
if (user != null) {
DatabaseReference db = FirebaseDatabase.getInstance().getReference()
.child("Users").child(user.getUid().toString()).child("username");
db.addListenerForSingleValueEvent(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
TextView bal = (TextView)a.findViewById(R.id.username);
bal.setText("Welcome: " + dataSnapshot.getValue());
}
@Override
public void onCancelled(DatabaseError databaseError) {
// ...
}
});
}
}
@Test
public void testSetWithPriority()
throws ExecutionException, TimeoutException, InterruptedException, TestFailure {
List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 2);
final DatabaseReference ref1 = refs.get(0);
final DatabaseReference ref2 = refs.get(1);
ReadFuture readFuture = ReadFuture.untilNonNull(ref1);
new WriteFuture(ref1, "hello", 5).timedGet();
List<EventRecord> result = readFuture.timedGet();
DataSnapshot snap = result.get(result.size() - 1).getSnapshot();
assertEquals(5.0, snap.getPriority());
assertEquals("hello", snap.getValue());
result = ReadFuture.untilNonNull(ref2).timedGet();
snap = result.get(result.size() - 1).getSnapshot();
assertEquals(5.0, snap.getPriority());
assertEquals("hello", snap.getValue());
}
public void updateProfileLikeCountAfterRemovingPost(Post post) {
DatabaseReference profileRef = databaseHelper
.getDatabaseReference()
.child(DatabaseHelper.PROFILES_DB_KEY + "/" + post.getAuthorId() + "/likesCount");
final long likesByPostCount = post.getLikesCount();
profileRef.runTransaction(new Transaction.Handler() {
@Override
public Transaction.Result doTransaction(MutableData mutableData) {
Integer currentValue = mutableData.getValue(Integer.class);
if (currentValue != null && currentValue >= likesByPostCount) {
mutableData.setValue(currentValue - likesByPostCount);
}
return Transaction.success(mutableData);
}
@Override
public void onComplete(DatabaseError databaseError, boolean b, DataSnapshot dataSnapshot) {
LogUtil.logInfo(TAG, "Updating likes count transaction is completed.");
}
});
}
/**
* @param query
* @return
*/
@NonNull
@CheckReturnValue
public static Single<DataSnapshot> single(@NonNull final Query query) {
return Single.create(new SingleOnSubscribe<DataSnapshot>() {
@Override
public void subscribe(
@NonNull final SingleEmitter<DataSnapshot> emit) throws Exception {
final ValueEventListener listener = listener(emit);
emit.setCancellable(new Cancellable() {
@Override
public void cancel() throws Exception {
query.removeEventListener(listener);
}
});
query.addListenerForSingleValueEvent(listener);
}
});
}
@Override
public void onCreate()
{
super.onCreate();
// For offline use
FirebaseDatabase.getInstance().setPersistenceEnabled(true);
Picasso.Builder builder = new Picasso.Builder(this);
builder.downloader(new OkHttpDownloader(this, Integer.MAX_VALUE));
Picasso build = builder.build();
build.setLoggingEnabled(true);
Picasso.setSingletonInstance(build);
// If user disconnect
if(FirebaseAuth.getInstance().getCurrentUser() != null)
{
final DatabaseReference userDatabase = FirebaseDatabase.getInstance().getReference().child("Users").child(FirebaseAuth.getInstance().getCurrentUser().getUid());
userDatabase.addValueEventListener(new ValueEventListener()
{
@Override
public void onDataChange(DataSnapshot dataSnapshot)
{
if(dataSnapshot != null)
{
userDatabase.child("online").onDisconnect().setValue(ServerValue.TIMESTAMP);
}
}
@Override
public void onCancelled(DatabaseError databaseError)
{
Log.d(TAG, "usersDatabase failed: " + databaseError.getMessage());
}
});
}
}
@Test
public void testWriteLeafNodeRemoveItTryToAddChildToRemovedNode()
throws ExecutionException, TimeoutException, InterruptedException, TestFailure {
List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 2);
final DatabaseReference reader = refs.get(0);
final DatabaseReference writer = refs.get(1);
writer.setValueAsync(5);
writer.removeValueAsync();
new WriteFuture(writer.child("abc"), 5).timedGet();
DataSnapshot snap = new ReadFuture(reader).timedGet().get(0).getSnapshot();
assertEquals(5L, ((Map) snap.getValue()).get("abc"));
}