io.reactivex.functions.Cancellable#com.google.firebase.database.Query源码实例Demo

private void addValueToReadyListener(final Query firebase, final GeoHashQuery query) {
    firebase.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            synchronized (GeoQuery.this) {
                GeoQuery.this.outstandingQueries.remove(query);
                GeoQuery.this.checkAndFireReady();
            }
        }

        @Override
        public void onCancelled(@NonNull final DatabaseError databaseError) {
            synchronized (GeoQuery.this) {
                for (final GeoQueryDataEventListener listener : GeoQuery.this.eventListeners) {
                    GeoQuery.this.geoFire.raiseEvent(new Runnable() {
                        @Override
                        public void run() {
                            listener.onGeoQueryError(databaseError);
                        }
                    });
                }
            }
        }
    });
}
 

private void assertIsKeptSynced(Query query) throws Exception {
  DatabaseReference ref = query.getRef();

  // First set a unique value to the value of a child.
  long counter = globalKeepSyncedTestCounter++;
  final Map<String, Object> value = new MapBuilder().put("child", counter).build();
  new WriteFuture(ref, value).timedGet();

  // Next go offline, if it's kept synced we should have kept the value, after going offline no
  // way to get the value except from cache
  ref.getDatabase().goOffline();

  new ReadFuture(
          query,
          (List<EventRecord> events) -> {
            assertEquals(1, events.size());
            assertEquals(value, events.get(0).getSnapshot().getValue());
            return true;
          })
      .timedGet();

  // All good, go back online
  ref.getDatabase().goOnline();
}
 

public void getPostListByUser(final OnDataChangedListener<Post> onDataChangedListener, String userId) {
    DatabaseReference databaseReference = databaseHelper.getDatabaseReference().child(DatabaseHelper.POSTS_DB_KEY);
    Query postsQuery;
    postsQuery = databaseReference.orderByChild("authorId").equalTo(userId);

    postsQuery.keepSynced(true);
    postsQuery.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            PostListResult result = parsePostList((Map<String, Object>) dataSnapshot.getValue());
            onDataChangedListener.onListChanged(result.getPosts());
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            LogUtil.logError(TAG, "getPostListByUser(), onCancelled", new Exception(databaseError.getMessage()));
        }
    });
}
 

public FirebaseQueryLiveDataElement(Class<T> genericTypeClass, Query query) {
    setValue(null);
    listener = new ValueEventListener() {

        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            T item = dataSnapshot.getValue(genericTypeClass);
            setValue(new FirebaseElement<>(item));
        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {
            setValue(new FirebaseElement<>(databaseError));
            removeListener();
            setListener();
        }
    };
    this.query = query;
}
 

public void addValueEventListener(final String name, final ReadableArray modifiers) {
  final FirestackDBReference self = this;

  mValueListener = new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
      self.handleDatabaseEvent("value", mPath, dataSnapshot);
    }

    @Override
    public void onCancelled(DatabaseError error) {
      self.handleDatabaseError("value", mPath, error);
    }
  };

  Query ref = this.getDatabaseQueryAtPathAndModifiers(modifiers);
  ref.addValueEventListener(mValueListener);
  this.setListeningTo(mPath, "value");
}
 

public void deleteFromFirebase(final String id){
    Query hekkQuery = mDatabaseReference;

    hekkQuery.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            dataSnapshot.child(id).getRef().removeValue()
                    .addOnSuccessListener(new OnSuccessListener<Void>() {
                        @Override
                        public void onSuccess(Void aVoid) {
                            deletePhotoFromStorage(id);
                        }
                    });
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
        }
    });

    /////this is for firebase storage
    Task<Void> task = mStorageReference.child(String.valueOf(id).concat("_Image")).delete();
}
 

@Override
public void onLoadFinished(Loader<Cursor> loader, final Cursor data) {
    adapter.swapCursor(data);

    if(data.getCount() == 0){
        Query hekkQuery = mDatabaseReference;

        hekkQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {

                if(doctorPreference.getWantToRestoreData(getActivity())){
                    if(dataSnapshot.getChildrenCount() == 0){

                    }else {
                        showAlertToRestoreData(dataSnapshot.getChildrenCount());
                    }
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
            }
        });
    }
}
 

private void addValueToReadyListener(final Query firebase, final GeoHashQuery query) {
    firebase.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            synchronized (GeoQuery.this) {
                GeoQuery.this.outstandingQueries.remove(query);
                GeoQuery.this.checkAndFireReady();
            }
        }

        @Override
        public void onCancelled(final DatabaseError databaseError) {
            synchronized (GeoQuery.this) {
                for (final GeoQueryDataEventListener listener : GeoQuery.this.eventListeners) {
                    GeoQuery.this.geoFire.raiseEvent(new Runnable() {
                        @Override
                        public void run() {
                            listener.onGeoQueryError(databaseError);
                        }
                    });
                }
            }
        }
    });
}
 

private FirebaseRecyclerAdapter<Post, PostViewHolder> getFirebaseRecyclerAdapter(Query query) {
    FirebaseRecyclerOptions<Post> options = new FirebaseRecyclerOptions.Builder<Post>()
            .setLifecycleOwner(this)
            .setQuery(query, Post.class)
            .build();

    return new FirebaseRecyclerAdapter<Post, PostViewHolder>(options) {
        @Override
        protected void onBindViewHolder(@NonNull PostViewHolder postViewHolder,
                                        int position,
                                        @NonNull Post post) {
            setupPost(postViewHolder, post, position, null);
        }

        @Override
        public PostViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            View view = LayoutInflater.from(parent.getContext())
                    .inflate(R.layout.post_item, parent, false);

            return new PostViewHolder(view);
        }
    };
}
 

public <T> Observable<T> getObjects(final Query query, final Class<T> objectClass, final boolean useRootElement) {
    return Observable.create(new Observable.OnSubscribe<T>() {
        @Override
        public void call(final Subscriber<? super T> subscriber) {
            query.addListenerForSingleValueEvent(new ValueEventListener() {
                @Override
                public void onDataChange(DataSnapshot dataSnapshot) {
                    if(useRootElement) {
                        converter.convert(dataSnapshot, objectClass, subscriber);
                    } else {
                        for (DataSnapshot entry : dataSnapshot.getChildren()) {
                            converter.convert(entry, objectClass, subscriber);
                        }
                    }
                    subscriber.onCompleted();
                }

                @Override
                public void onCancelled(DatabaseError databaseError) {

                }
            });
        }
    });
}
 

@Override
public Query resolve(OrderByClause orderByClause, Query target) {
    switch (orderByClause.getOrderByMode()) {
        case ORDER_BY_CHILD:
            if (orderByClause.getArgument() == null) {
                throw new IllegalArgumentException(MISSING_ARGUMENT);
            }
            return target.orderByChild(orderByClause.getArgument());
        case ORDER_BY_KEY:
            return target.orderByKey();
        case ORDER_BY_VALUE:
            return target.orderByValue();
        default:
            throw new IllegalStateException();
    }
}
 

/**
 * @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);
        }
    });
}
 

@Test
public void applyFiltering1() {
    // Given
    ProviderQueryFiltering provider = new ProviderQueryFiltering();
    OrderByClause orderByClause = new OrderByClause(OrderByMode.ORDER_BY_KEY, "test");
    Array<Filter> filters = new Array<>(new Filter[]{new Filter(FilterType.LIMIT_FIRST, 2)});
    Query query = Mockito.mock(Query.class);
    Mockito.when(query.limitToFirst(Mockito.anyInt())).thenReturn(query);
    Mockito.when(query.orderByKey()).thenReturn(query);
    provider.setQuery(query);
    provider.setFilters(filters);
    provider.setOrderByClause(orderByClause);

    // When
    Object result = provider.applyFiltering();

    // Then
    Assert.assertNotNull(result);
}
 

public void getPostListByUser(final OnDataChangedListener<Post> onDataChangedListener, String userId) {
    DatabaseReference databaseReference = databaseHelper.getDatabaseReference().child(DatabaseHelper.POSTS_DB_KEY);
    Query postsQuery;
    postsQuery = databaseReference.orderByChild("authorId").equalTo(userId);

    postsQuery.keepSynced(true);
    postsQuery.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            PostListResult result = parsePostList((Map<String, Object>) dataSnapshot.getValue());
            onDataChangedListener.onListChanged(result.getPosts());
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            LogUtil.logError(TAG, "getPostListByUser(), onCancelled", new Exception(databaseError.getMessage()));
        }
    });
}
 

/**
 * @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);
        }
    });
}
 

public void basicQueryValueListener() {
    String myUserId = getUid();
    Query myTopPostsQuery = databaseReference.child("user-posts").child(myUserId)
            .orderByChild("starCount");

    // [START basic_query_value_listener]
    // My top posts by number of stars
    myTopPostsQuery.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            for (DataSnapshot postSnapshot: dataSnapshot.getChildren()) {
                // TODO: handle the post
            }
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            // Getting Post failed, log a message
            Log.w(TAG, "loadPost:onCancelled", databaseError.toException());
            // ...
        }
    });
    // [END basic_query_value_listener]
}
 

private void AddPosts()
{
    Query allposts = donor_ref.child("posts");
    pd.show();
    allposts.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {

            if(dataSnapshot.exists()) {

                for (DataSnapshot singlepost : dataSnapshot.getChildren()) {
                    CustomUserData customUserData = singlepost.getValue(CustomUserData.class);
                    postLists.add(customUserData);
                    restAdapter.notifyDataSetChanged();
                }
                pd.dismiss();
            }
            else
            {
                Toast.makeText(getActivity(), "Database is empty now!",
                        Toast.LENGTH_LONG).show();
            }
        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {

            Log.d("User", databaseError.getMessage());

        }
    });

}
 

public ReadFuture(final Query ref) {
  this(
      ref,
      new CompletionCondition() {
        @Override
        public boolean isComplete(List<EventRecord> events) {
          return true;
        }
      });
}
 

public static ReadFuture untilNonNull(Query ref) {
  return new ReadFuture(
      ref,
      new CompletionCondition() {
        @Override
        public boolean isComplete(List<EventRecord> events) {
          return events.get(events.size() - 1).getSnapshot().getValue() != null;
        }
      });
}
 

private void reset() {
    for(Map.Entry<GeoHashQuery, Query> entry: this.firebaseQueries.entrySet()) {
        entry.getValue().removeEventListener(this.childEventLister);
    }
    this.outstandingQueries.clear();
    this.firebaseQueries.clear();
    this.queries = null;
    this.locationInfos.clear();
}
 

public static ReadFuture untilEquals(Query ref, final Object value, boolean ignoreFirstNull) {
  return new ReadFuture(
      ref,
      new CompletionCondition() {
        @Override
        public boolean isComplete(List<EventRecord> events) {
          Object eventValue = events.get(events.size() - 1).getSnapshot().getValue();
          return eventValue != null && eventValue.equals(value);
        }
      },
      ignoreFirstNull);
}
 

private void assertNotKeptSynced(Query query) throws Exception {
  DatabaseReference ref = query.getRef();

  // First set a unique value to the value of a child.
  long current = globalKeepSyncedTestCounter++;
  final Map<String, Object> oldValue = new MapBuilder().put("child", current).build();

  long next = globalKeepSyncedTestCounter++;
  final Map<String, Object> nextValue = new MapBuilder().put("child", next).build();

  new WriteFuture(ref, oldValue).timedGet();

  // Next go offline, if it's kept synced we should have kept the value and we'll get an even
  // with the *old* value.
  ref.getDatabase().goOffline();

  ReadFuture readFuture =
      new ReadFuture(
          query,
          (List<EventRecord> events) -> {
            // We expect this to get called with the next value, not the old value.
            assertEquals(1, events.size());
            assertEquals(nextValue, events.get(0).getSnapshot().getValue());
            return true;
          });

  // By now, if we had it synced we should have gotten an event with the wrong value
  // Write a new value so the value event listener will be triggered
  ref.setValue(nextValue);
  readFuture.timedGet();

  // All good, go back online
  ref.getDatabase().goOnline();
}
 

@Test
public void keepSyncedAffectsQueries() throws Exception {
  DatabaseReference ref = IntegrationTestHelpers.getRandomNode();
  ref.keepSynced(true);
  Query query = ref.limitToFirst(5);
  query.keepSynced(true);
  assertIsKeptSynced(ref);

  ref.keepSynced(false);
  assertNotKeptSynced(ref);
  assertNotKeptSynced(
      query); // currently, setting false on the default query affects all queries at that
  // location
}
 

/**
 * Sets the query using a {@link ClassSnapshotParser} based
 * on the given class.
 *
 * See {@link #setQuery(Query, PagedList.Config, SnapshotParser)}.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull PagedList.Config config,
                           @NonNull Class<T> modelClass) {
    return setQuery(query, config, new ClassSnapshotParser<>(modelClass));
}
 

public static FirebaseListOptions<Poem> getUserListOptions(int layout) {
    String userId = getUserId();
    DatabaseReference poemsRef = FirebaseDatabase.getInstance().getReference(userId);
    Query poemsQuery = poemsRef.orderByChild("inverseCreationTimeStamp");

    return new FirebaseListOptions.Builder<Poem>()
            .setQuery(poemsQuery, Poem.class)
            .setLayout(layout)
            .build();
}
 

public void setQuery(Query query) {
    removeListener();
    liveDataSet.clear();
    setValue(new FirebaseElement<>(liveDataSet));
    this.query = query;
    setListener();
}
 

/**
 * Sets the Database query to paginate.
 *
 * @param query the FirebaseDatabase query. This query should only contain orderByKey(), orderByChild() and
 *              orderByValue() clauses. Any limit will cause an error such as limitToLast() or limitToFirst().
 * @param config paging configuration, passed directly to the support paging library.
 * @param parser the {@link SnapshotParser} to parse {@link DataSnapshot} into model
 *               objects.
 * @return this, for chaining.
 */
@NonNull
public Builder<T> setQuery(@NonNull Query query,
                           @NonNull PagedList.Config config,
                           @NotNull SnapshotParser<T> parser) {
    FirebaseDataSource.Factory factory = new FirebaseDataSource.Factory(query);
    mData = new LivePagedListBuilder<>(factory, config).build();

    mParser = parser;
    return this;
}
 

private  void putInformationInFb(final Context context) {

        // TODO: Send messages on click
        FirebaseDatabase mFirebaseDatabase = FirebaseDatabase.getInstance();
        final DatabaseReference mDatabaseReference = mFirebaseDatabase.getReference();
        Query hekkQuery = mDatabaseReference;

        hekkQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                boolean alreadyHas = false;
                for (DataSnapshot snapshot: dataSnapshot.getChildren()) {
                    if (snapshot.getKey().equals(phone)){
                        alreadyHas = true;
                        saveUserInSP(context);
                    }
                }
                if(!alreadyHas){
                    mDatabaseReference.child(phone).setValue("").addOnSuccessListener(new OnSuccessListener<Void>() {
                        @Override
                        public void onSuccess(Void aVoid) {
                            saveUserInSP(context);
                        }
                    })
                            .addOnFailureListener(new OnFailureListener() {
                                @Override
                                public void onFailure(@NonNull Exception e) {

                                }
                            });
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
            }
        });

    }
 

public void updateInFirebase(final String id, final patientsInfo info){
    Query hekkQuery = mDatabaseReference;

    hekkQuery.addValueEventListener(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            dataSnapshot.child(id).getRef().setValue(info);
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
        }
    });

}
 

@Test
public void testQueriesOnLeafNodes()
    throws InterruptedException, ExecutionException, TestFailure, TimeoutException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp) ;
  final Semaphore semaphore = new Semaphore(0);
  new WriteFuture(ref, "leaf-node").timedGet();

  final List<DataSnapshot> snapshots = new ArrayList<>();
  Query query = ref.orderByChild("foo").limitToLast(1);
  final ValueEventListener listener =
      query.addValueEventListener(
          new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
              snapshots.add(snapshot);
              semaphore.release();
            }

            @Override
            public void onCancelled(DatabaseError error) {
              Assert.fail();
            }
          });

  TestHelpers.waitFor(semaphore);

  Assert.assertEquals(1, snapshots.size());
  Assert.assertNull(snapshots.get(0).getValue());

  // cleanup
  TestHelpers.waitForRoundtrip(ref);
  ref.removeEventListener(listener);
}