io.reactivex.annotations.CheckReturnValue#com.google.firebase.database.DatabaseReference源码实例Demo

@Test
public void testCreateBasicQueries() {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);

  // Just make sure they don't throw anything
  ref.limitToLast(10);
  ref.startAt("199").limitToLast(10);
  ref.startAt("199", "test").limitToLast(10);
  ref.endAt(199).limitToLast(1);
  ref.startAt(50, "test").endAt(100, "tree");
  ref.startAt(4).endAt(10);
  ref.startAt(null).endAt(10);
  ref.orderByChild("child");
  ref.orderByChild("child/deep/path");
  ref.orderByValue();
  ref.orderByPriority();
}
 

private void updateFirebaseToken() {
    FirebaseDatabase db=FirebaseDatabase.getInstance();
    final DatabaseReference tokens=db.getReference(Common.token_tbl);

    final Token token=new Token(FirebaseInstanceId.getInstance().getToken());
    if(FirebaseAuth.getInstance().getUid()!=null) tokens.child(FirebaseAuth.getInstance().getUid()).setValue(token);
    else if(account!=null) tokens.child(account.getId()).setValue(token);
    else{
        GraphRequest request = GraphRequest.newMeRequest(
                accessToken,
                new GraphRequest.GraphJSONObjectCallback() {
                    @Override
                    public void onCompleted(JSONObject object, GraphResponse response) {
                        String id = object.optString("id");
                        tokens.child(id).setValue(token);
                    }
                });
        request.executeAsync();
    }
}
 

@Test
public void testNameAndRefForSnapshots()
    throws TestFailure, ExecutionException, TimeoutException, InterruptedException {

  DatabaseReference ref = FirebaseDatabase.getInstance(masterApp).getReference();
  // Clear any data there
  new WriteFuture(ref, MapBuilder.of("foo", 10)).timedGet();

  DataSnapshot snap = TestHelpers.getSnap(ref);
  assertNull(snap.getKey());
  assertEquals(ref.toString(), snap.getRef().toString());
  DataSnapshot childSnap = snap.child("a");
  assertEquals("a", childSnap.getKey());
  assertEquals(ref.child("a").toString(), childSnap.getRef().toString());
  childSnap = childSnap.child("b/c");
  assertEquals("c", childSnap.getKey());
  assertEquals(ref.child("a/b/c").toString(), childSnap.getRef().toString());
}
 

private void warmSpeakers() {
    final DatabaseReference ref = fdb.getReference("/sections/speakers");
    ref.addValueEventListener(new ExecutorValueEventListener(executor) {
        @Override
        public void onDataChangeExecutor(final DataSnapshot data) {
            LOGGER.fine("New Speaker data");
            speakers = FirebaseDatabaseHelpers.toSpeakersSection(data);
            bus.post(speakers);
        }

        @Override
        public void onCancelledExecutor(final DatabaseError databaseError) {
            LOGGER.log(Level.SEVERE, "Error reading speakers", databaseError.toException());
        }
    });
}
 

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

@Override public void onRestore(@NonNull DatabaseReference databaseReference, @Nullable String userId) {
    this.userId = userId;
    FirebaseUser user = getView().user();
    if (InputHelper.isEmpty(userId)) {
        if (user != null) userId = user.getUid();
    }
    if (InputHelper.isEmpty(userId)) {
        getView().onShowMessage(R.string.login_first_msg);
        getView().finishOnError();
    } else {
        getView().onShowProgress();
        Query query = databaseReference
                .child(userId);
        query.keepSynced(true);
        query.addListenerForSingleValueEvent(this);
    }
}
 

@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 testWriteLargeLongValueThenIncrement() throws InterruptedException {
  List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 1);
  DatabaseReference node = refs.get(0);

  final EventHelper readHelper =
      new EventHelper()
          .addValueExpectation(node, Long.MAX_VALUE)
          .addValueExpectation(node, Long.MAX_VALUE * 2.0)
          .startListening(true);

  ZombieVerifier.verifyRepoZombies(refs);
  node.setValueAsync(Long.MAX_VALUE);
  node.setValueAsync(Long.MAX_VALUE * 2.0);

  TestHelpers.waitForRoundtrip(node);
  assertTrue(readHelper.waitForEvents());
  ZombieVerifier.verifyRepoZombies(refs);
  readHelper.cleanup();
}
 

@Override
public void onBindViewHolder(final PostViewHolder holder, int position) {
    DatabaseReference ref = FirebaseUtil.getPostsRef().child(mPostPaths.get(position));
    // TODO: Fix this so async event won't bind the wrong view post recycle.
    ValueEventListener postListener = new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            Post post = dataSnapshot.getValue(Post.class);
            Log.d(TAG, "post key: " + dataSnapshot.getKey());
            mOnSetupViewListener.onSetupView(holder, post, holder.getAdapterPosition(),
                    dataSnapshot.getKey());
        }

        @Override
        public void onCancelled(DatabaseError firebaseError) {
            Log.e(TAG, "Error occurred: " + firebaseError.getMessage());
        }
    };
    ref.addValueEventListener(postListener);
    holder.mPostRef = ref;
    holder.mPostListener = postListener;
}
 

@Test
public void testEndAtWithTwoArgumentsAndLimit()
    throws TestFailure, ExecutionException, TimeoutException, InterruptedException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);

  Map<String, Object> toSet = new MapBuilder().put("a", "a")
      .put("b", "b").put("c", "c").put("d", "d").put("e", "e").put("f", "f")
      .put("g", "g").put("h", "h").build();

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

  DataSnapshot snap = TestHelpers.getSnap(ref.endAt(null, "f").limitToLast(5));
  Map<String, Object> expected = new MapBuilder().put("b", "b")
      .put("c", "c").put("d", "d").put("e", "e").put("f", "f").build();

  TestHelpers.assertDeepEquals(expected, snap.getValue());
}
 

public static ChatMessage addMessage(
        DatabaseReference firebaseDb,
        String groupId,
        ChatMessage message){

    DatabaseReference pushRef = firebaseDb
            .child("chat")
            .child("messages")
            .child(groupId)
            .push();

    pushRef.setValue(message.toMap());

    message.setId(pushRef.getKey());
    return message;
}
 

@Test
public void testWriteIntegerValueThenChangeToDoubleWithDifferentPriority()
    throws InterruptedException {
  List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 1);
  DatabaseReference node = refs.get(0);

  final EventHelper readHelper =
      new EventHelper()
          .addValueExpectation(node, 1337)
          .addValueExpectation(node, 1337)
          .startListening(true);

  ZombieVerifier.verifyRepoZombies(refs);

  node.setValueAsync(1337);
  node.setValueAsync(1337.0, 1337);

  TestHelpers.waitForRoundtrip(node);
  assertTrue(readHelper.waitForEvents());
  ZombieVerifier.verifyRepoZombies(refs);
  readHelper.cleanup();
}
 

void callOnComplete(
    final DatabaseReference.CompletionListener onComplete,
    final DatabaseError error,
    final Path path) {
  if (onComplete != null) {
    final DatabaseReference ref;
    ChildKey last = path.getBack();
    if (last != null && last.isPriorityChildName()) {
      ref = InternalHelpers.createReference(this, path.getParent());
    } else {
      ref = InternalHelpers.createReference(this, path);
    }
    postEvent(
        new Runnable() {
          @Override
          public void run() {
            onComplete.onComplete(error, ref);
          }
        });
  }
}
 

@Test
public void testUpdateRaisesChildEventsOnNewListener() throws InterruptedException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);
  EventHelper helper = new EventHelper().addValueExpectation(ref.child("a"))
      .addValueExpectation(ref.child("d"))
      .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "a")
      .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "d")
      .addValueExpectation(ref.child("c")).addValueExpectation(ref.child("d"))
      .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "c")
      .addChildExpectation(ref, Event.EventType.CHILD_CHANGED, "d").startListening();

  ref.updateChildrenAsync(new MapBuilder().put("a", 11).put("d", 44).build());
  ref.updateChildrenAsync(new MapBuilder().put("c", 33).put("d", 45).build());
  helper.waitForEvents();
  helper.cleanup();
}
 

@Test
public void testStartAtEndAtWithPriority() throws InterruptedException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);

  ValueExpectationHelper helper = new ValueExpectationHelper();
  helper.add(ref.startAt("w").endAt("y"),
      MapBuilder.of("b", 2L, "c", 3L, "d", 4L));
  helper.add(ref.startAt("w").endAt("w"), MapBuilder.of("d", 4L));
  helper.add(ref.startAt("a").endAt("c"), null);

  ref.setValueAsync(
      new MapBuilder()
          .put("a", MapBuilder.of(".value", 1, ".priority", "z"))
          .put("b", MapBuilder.of(".value", 2, ".priority", "y"))
          .put("c", MapBuilder.of(".value", 3, ".priority", "x"))
          .put("d", MapBuilder.of(".value", 4, ".priority", "w")).build());

  helper.waitForEvents();
}
 

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()));
        }
    });
}
 

@Test
public void simpleMergeTest() throws Throwable {
  PersistenceManager manager = newTestPersistenceManager();
  DatabaseConfig cfg1 = newFrozenTestConfig();
  DatabaseReference ref1 = refWithConfig(cfg1, manager).push();
  goOffline(cfg1);
  Map<String, Object> updates = new HashMap<String, Object>();
  updates.put("foo", "bar");
  ref1.updateChildren(updates);
  waitForQueue(ref1);

  DatabaseConfig cfg2 = newFrozenTestConfig();
  DatabaseReference ref2 = refWithConfig(cfg2, manager);
  ref2 = ref2.child(ref1.getKey());

  Object value = new ReadFuture(ref2).waitForLastValue();
  assertEquals(updates, value);
}
 

@Test
public void deepUpdateTest() throws Throwable {
  PersistenceManager manager = newTestPersistenceManager();
  DatabaseConfig cfg1 = newFrozenTestConfig();
  DatabaseReference ref1 = refWithConfig(cfg1, manager).push();
  goOffline(cfg1);
  Map<String, Object> updates = new HashMap<String, Object>();
  updates.put("foo/deep/update", "bar");
  ref1.updateChildren(updates);
  waitForQueue(ref1);

  DatabaseConfig cfg2 = newFrozenTestConfig();
  DatabaseReference ref2 = refWithConfig(cfg2, manager);
  ref2 = ref2.child(ref1.getKey());

  Object value = new ReadFuture(ref2).waitForLastValue();
  assertEquals(value, fromSingleQuotedString("{ 'foo': { 'deep': { 'update': 'bar' } } }"));
}
 

@Test
public void testChildEventsOnPriorityChanges() throws InterruptedException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);

  final EventHelper helper =
      new EventHelper()
          .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "a")
          .addValueExpectation(ref)
          .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "b")
          .addValueExpectation(ref)
          .addChildExpectation(ref, Event.EventType.CHILD_ADDED, "c")
          .addValueExpectation(ref)
          .addChildExpectation(ref, Event.EventType.CHILD_MOVED, "a")
          .addChildExpectation(ref, Event.EventType.CHILD_CHANGED, "a")
          .addValueExpectation(ref)
          .startListening(true);

  ref.child("a").setValueAsync("first", 1);
  ref.child("b").setValueAsync("second", 5);
  ref.child("c").setValueAsync("third", 10);
  ref.child("a").setPriorityAsync(15);

  assertTrue(helper.waitForEvents());
  helper.cleanup();
}
 

@Override
protected ArrayList<Route> doInBackground(String... params) {
    //Return the retrieved list of person's  routes from firebase
    String id=params[0];
    String route_ref="Routes/"+id;
    DatabaseReference routes_ref= FirebaseDatabase.getInstance().getReference(route_ref);
    routes_ref.keepSynced(true);
    routes_ref.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            for (DataSnapshot routes:dataSnapshot.getChildren()){
                Route temp=routes.getValue(Route.class);
                Log.i(TAG,temp.getName());
                routes_list.add(temp);
            }
            messenger_to_activity.onTaskCompleted(routes_list);
        }

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

public void deleteConversation(final String conversationId, final ConversationsListener conversationsListener) {

        // the node of the conversation with conversationId
        DatabaseReference nodeConversation = conversationsNode.child(conversationId);

        nodeConversation.removeValue(new DatabaseReference.CompletionListener() {
            @Override
            public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {

                if (databaseError == null) {
                    deleteConversationFromMemory(conversationId);
                    conversationsListener.onConversationRemoved(null);
                } else {
                    conversationsListener.onConversationRemoved(new ChatRuntimeException(databaseError.toException()));
                }
            }
        });
    }
 

private DatabaseReference getFollowersRef(String userId) {
    return databaseHelper
            .getDatabaseReference()
            .child(DatabaseHelper.FOLLOW_DB_KEY)
            .child(userId)
            .child(DatabaseHelper.FOLLOWERS_DB_KEY);
}
 

public void getPostList(final OnPostListChangedListener<Post> onDataChangedListener, long date) {
    DatabaseReference databaseReference = databaseHelper.getDatabaseReference().child(DatabaseHelper.POSTS_DB_KEY);
    Query postsQuery;
    if (date == 0) {
        postsQuery = databaseReference.limitToLast(Constants.Post.POST_AMOUNT_ON_PAGE).orderByChild("createdDate");
    } else {
        postsQuery = databaseReference.limitToLast(Constants.Post.POST_AMOUNT_ON_PAGE).endAt(date).orderByChild("createdDate");
    }

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

            if (result.getPosts().isEmpty() && result.isMoreDataAvailable()) {
                getPostList(onDataChangedListener, result.getLastItemCreatedDate() - 1);
            } else {
                onDataChangedListener.onListChanged(parsePostList(objectMap));
            }
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            LogUtil.logError(TAG, "getPostList(), onCancelled", new Exception(databaseError.getMessage()));
            onDataChangedListener.onCanceled(context.getString(R.string.permission_denied_error));
        }
    });
}
 

public void removeValueEventListener() {
  DatabaseReference ref = this.getDatabaseRef();
  if (mValueListener != null) {
    ref.removeEventListener(mValueListener);
    this.notListeningTo(mPath, "value");
    mValueListener = null;
  }
  if (mOnceValueListener != null) {
    ref.removeEventListener(mOnceValueListener);
    mOnceValueListener = null;
  }
}
 

@Test
public void testCacheInvalidation()
    throws InterruptedException, TestFailure, TimeoutException {
  List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 2);
  DatabaseReference reader = refs.get(0);
  DatabaseReference writer = refs.get(1);

  final AtomicBoolean startChecking = new AtomicBoolean(false);
  final Semaphore ready = new Semaphore(0);
  final ReadFuture future = new ReadFuture(reader.limitToLast(2), 
      new ReadFuture.CompletionCondition() {
        @Override
        public boolean isComplete(List<EventRecord> events) {
          DataSnapshot snap = events.get(events.size() - 1).getSnapshot();
          Object result = snap.getValue();
          if (startChecking.compareAndSet(false, true) && result == null) {
            ready.release(1);
            return false;
          }
          // We already initialized the location, and now the remove has
          // happened
          // so that
          // we have no more data
          return startChecking.get() && result == null;
        }
      });

  TestHelpers.waitFor(ready);
  for (int i = 0; i < 4; ++i) {
    writer.child("k" + i).setValueAsync(i);
  }

  writer.removeValueAsync();
  future.timedGet();
}
 

private void getAssignedCustomerDestination(){
    String driverId = FirebaseAuth.getInstance().getCurrentUser().getUid();
    DatabaseReference assignedCustomerRef = FirebaseDatabase.getInstance().getReference().child("Users").child("Drivers").child(driverId).child("customerRequest");
    assignedCustomerRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            if(dataSnapshot.exists()) {
                Map<String, Object> map = (Map<String, Object>) dataSnapshot.getValue();
                if(map.get("destination")!=null){
                    destination = map.get("destination").toString();
                    mCustomerDestination.setText("Destination: " + destination);
                }
                else{
                    mCustomerDestination.setText("Destination: --");
                }

                Double destinationLat = 0.0;
                Double destinationLng = 0.0;
                if(map.get("destinationLat") != null){
                    destinationLat = Double.valueOf(map.get("destinationLat").toString());
                }
                if(map.get("destinationLng") != null){
                    destinationLng = Double.valueOf(map.get("destinationLng").toString());
                    destinationLatLng = new LatLng(destinationLat, destinationLng);
                }

            }
        }

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

private void updateUI(FirebaseUser currentUser) {
    if (currentUser == null) {
        progressView.setVisibility(View.GONE);
        return;
    }
    showProgressView();
    final DatabaseReference userReference = FirebaseDatabase.getInstance().getReference("users").child(currentUser.getUid());
    userReference.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            User user = dataSnapshot.getValue(User.class);
            if (user != null) {
                startActivity(new Intent(SignInActivity.this, MainActivity.class));
                finish();
            } else {
                runTransaction(userReference);
            }

        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {
            loginError("Firebase fetch user data failed.");
            hideProgressView();
        }
    });


}
 

@Test
public void testNegativeIntegerKeys()
    throws TestFailure, ExecutionException, TimeoutException, InterruptedException {
  DatabaseReference ref = IntegrationTestUtils.getRandomNode(masterApp);

  new WriteFuture(ref,
      new MapBuilder().put("-1", "minus-one").put("0", "zero").put("1", "one").build())
          .timedGet();

  DataSnapshot snap = TestHelpers.getSnap(ref);
  Map<String, Object> expected = new MapBuilder().put("-1", "minus-one").put("0", "zero")
      .put("1", "one").build();
  Object result = snap.getValue();
  TestHelpers.assertDeepEquals(expected, result);
}
 

private void runTransaction(DatabaseReference userReference) {
    showProgressView();
    userReference.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            User user = mutableData.getValue(User.class);
            if (user == null) {
                mutableData.setValue(new User());
                return Transaction.success(mutableData);
            }

            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean committed,
                               DataSnapshot dataSnapshot) {
            if (committed) {
                startActivity(new Intent(SignInActivity.this, MainActivity.class));
                finish();
            } else {
                errorTextView.setText("Firebase create user transaction failed.");
                hideProgressView();
            }
        }
    });
}
 

@Test
public void testUpdateFiresCorrectEventWhenAllChildrenAreDeleted()
    throws TestFailure, ExecutionException, TimeoutException, InterruptedException {
  List<DatabaseReference> refs = IntegrationTestUtils.getRandomNode(masterApp, 2);
  DatabaseReference writer = refs.get(0);
  DatabaseReference reader = refs.get(1);

  final ReadFuture writerFuture = ReadFuture.untilCountAfterNull(writer, 2);
  new WriteFuture(writer, MapBuilder.of("a", 12)).timedGet();
  final Semaphore semaphore = new Semaphore(0);
  final ReadFuture readerFuture = new ReadFuture(reader, new ReadFuture.CompletionCondition() {
    @Override
    public boolean isComplete(List<EventRecord> events) {
      if (events.size() == 1) {
        semaphore.release();
      }
      return events.size() == 2;
    }
  });

  TestHelpers.waitFor(semaphore);

  writer.updateChildrenAsync(MapBuilder.of("a", null));
  DataSnapshot snap = writerFuture.timedGet().get(1).getSnapshot();

  assertNull(snap.getValue());

  snap = readerFuture.timedGet().get(1).getSnapshot();

  assertNull(snap.getValue());
}