com.google.firebase.database.GenericTypeIndicator Java Examples

/**
 * Converts a standard library Java representation of JSON data to an object of the class provided
 * through the GenericTypeIndicator
 *
 * @param object The representation of the JSON data
 * @param typeIndicator The indicator providing class of the object to convert to
 * @return The POJO object.
 */
public static <T> T convertToCustomClass(Object object, GenericTypeIndicator<T> typeIndicator) {
  Class<?> clazz = typeIndicator.getClass();
  Type genericTypeIndicatorType = clazz.getGenericSuperclass();
  if (genericTypeIndicatorType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) genericTypeIndicatorType;
    if (!parameterizedType.getRawType().equals(GenericTypeIndicator.class)) {
      throw new DatabaseException(
          "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
    }
    // We are guaranteed to have exactly one type parameter
    Type type = parameterizedType.getActualTypeArguments()[0];
    return deserializeToType(object, type);
  } else {
    throw new DatabaseException(
        "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
  }
}
 

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

  writer.child("a").child("b").child("c").setValueAsync(1);
  writer.child("a").child("d").child("e").setValueAsync(2);
  writer.child("a").child("d").child("f").setValueAsync(3);
  WriteFuture writeFuture = new WriteFuture(writer.child("g"), 4);
  writeFuture.timedGet();

  Map<String, Object> expected = new MapBuilder()
      .put("a",
          new MapBuilder().put("b", new MapBuilder().put("c", 1L).build())
              .put("d", new MapBuilder().put("e", 2L).put("f", 3L).build()).build())
      .put("g", 4L).build();
  ReadFuture readFuture = new ReadFuture(reader);

  GenericTypeIndicator<Map<String, Object>> t = new GenericTypeIndicator<Map<String, Object>>() {
  };
  Map<String, Object> result = readFuture.timedGet().get(0).getSnapshot().getValue(t);
  TestHelpers.assertDeepEquals(expected, result);
}
 

/**
 * Converts a standard library Java representation of JSON data to an object of the class provided
 * through the GenericTypeIndicator
 *
 * @param object The representation of the JSON data
 * @param typeIndicator The indicator providing class of the object to convert to
 * @return The POJO object.
 */
public static <T> T convertToCustomClass(Object object, GenericTypeIndicator<T> typeIndicator) {
  Class<?> clazz = typeIndicator.getClass();
  Type genericTypeIndicatorType = clazz.getGenericSuperclass();
  if (genericTypeIndicatorType instanceof ParameterizedType) {
    ParameterizedType parameterizedType = (ParameterizedType) genericTypeIndicatorType;
    if (!parameterizedType.getRawType().equals(GenericTypeIndicator.class)) {
      throw new DatabaseException(
          "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
    }
    // We are guaranteed to have exactly one type parameter
    Type type = parameterizedType.getActualTypeArguments()[0];
    return deserializeToType(object, type);
  } else {
    throw new DatabaseException(
        "Not a direct subclass of GenericTypeIndicator: " + genericTypeIndicatorType);
  }
}
 

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 static List<FeedbackQuestion> toFeedbackQuestions(final DataSnapshot data) {
    final List<FeedbackQuestion2> questions = data.getValue(new GenericTypeIndicator<List<FeedbackQuestion2>>() {});
    int size = questions != null ? questions.size() : 0;
    ArrayList<FeedbackQuestion> qs = new ArrayList<>(size);
    if (questions != null) {
        for (final FeedbackQuestion2 q : questions) {
            qs.add(new FeedbackQuestion(QuestionType.valueOf(q.getType()), q.getText()));
        }
    }
    return qs;

}
 

public static MapsSection toMapsSection(DataSnapshot data) {
    final MapsSection section = new MapsSection();
    populateSection(data, section);
    Map<String, MapItem> items = data.child("items").getValue(new GenericTypeIndicator<Map<String, MapItem>>() {});
    if (items == null) {
        items = Collections.emptyMap();
    }
    section.setItems(items);
    return section;
}
 

public static CompaniesSection toCompaniesSection(final DataSnapshot data) {
    final CompaniesSection section = new CompaniesSection();
    populateSection(data, section);
    Map<String, CompanyItem> items = data.child("items").getValue(new GenericTypeIndicator<Map<String, CompanyItem>>() {});
    if (items == null) {
        items = Collections.emptyMap();
    }
    section.setItems(items);
    return section;
}
 

public static AttendeesSection toAttendeesSection(final DataSnapshot data) {
    final AttendeesSection section = new AttendeesSection();
    populateSection(data, section);
    Map<String, AttendeeItem> items = data.child("items").getValue(new GenericTypeIndicator<Map<String, AttendeeItem>>() {});
    if (items == null) {
        items = Collections.emptyMap();
    }
    section.setItems(items);
    return section;
}
 

public static SpeakersSection toSpeakersSection(final DataSnapshot data) {
    final SpeakersSection section = new SpeakersSection();
    populateSection(data, section);
    Map<String, SpeakerItem> items = data.child("items").getValue(new GenericTypeIndicator<Map<String, SpeakerItem>>() {});
    if (items == null) {
        items = Collections.emptyMap();
    }
    section.setItems(items);
    return section;
}
 

@Override
public void onDataChange(DataSnapshot dataSnapshot) {
    LOGGER.fine("Answers");
    LOGGER.fine(dataSnapshot.toString());
    priorAnswers = dataSnapshot.getValue(new GenericTypeIndicator<List<Object>>() {});
    if (priorAnswers == null) {
        priorAnswers = new ArrayList<>();
    }
    updateUi();
}
 

private <T> void callValueEventOnDataChange(GenericTypeIndicator<T> type, T value) {
    when(mockDataSnapshot.exists())
            .thenReturn(true);
    when(mockDataSnapshot.getValue(type))
            .thenReturn(value);

    valueEventListener.getValue().onDataChange(mockDataSnapshot);
}
 

private <T> void callValueEventOnDataChange(GenericTypeIndicator<T> type, T value) {
    when(mockDataSnapshot.exists())
            .thenReturn(true);
    when(mockDataSnapshot.getValue(type))
            .thenReturn(value);

    valueEventListener.getValue().onDataChange(mockDataSnapshot);
}
 

@Test
public void testDataOfGenericTypeIndicator_Query() {
    List<String> values = new ArrayList<>();
    values.add("Foo");
    values.add("Bar");

    GenericTypeIndicator<List<String>> typeIndicator =
            new GenericTypeIndicator<List<String>>() {
            };

    TestObserver<List<String>> sub = TestObserver.create();

    RxFirebaseDatabase.dataOf(mockQuery, typeIndicator)
            .subscribe(sub);

    verifyQueryAddListenerForSingleValueEvent();
    callValueEventOnDataChange(typeIndicator, values);

    sub.assertComplete();
    sub.assertNoErrors();

    sub.assertValue(new Predicate<List<String>>() {
        @Override
        public boolean test(List<String> value) throws Exception {
            return "Foo".equals(value.get(0))
                    && "Bar".equals(value.get(1));
        }
    });

    sub.dispose();

    callValueEventOnDataChange(typeIndicator, values);

    // Ensure no more values are emitted after unsubscribe
    sub.assertValueCount(1);
}
 

@Test
public void testDataChangesOfGenericTypeIndicator_Query() {
    List<String> values = new ArrayList<>();
    values.add("Foo");
    values.add("Bar");

    GenericTypeIndicator<List<String>> typeIndicator =
            new GenericTypeIndicator<List<String>>() {
            };

    TestObserver<DataValue<List<String>>> sub = TestObserver.create();

    RxFirebaseDatabase.dataChangesOf(mockQuery, typeIndicator)
            .subscribe(sub);

    verifyQueryAddValueEventListener();
    callValueEventOnDataChange(typeIndicator, values);

    sub.assertNotComplete();

    sub.assertValue(new Predicate<DataValue<List<String>>>() {
        @Override
        public boolean test(DataValue<List<String>> value) throws Exception {
            return value.isPresent()
                    && "Foo".equals(value.get().get(0))
                    && "Bar".equals(value.get().get(1));
        }
    });

    sub.dispose();

    callValueEventOnDataChange(typeIndicator, values);

    // Ensure no more values are emitted after unsubscribe
    sub.assertValueCount(1);
}
 

@Test
public void testDataOfGenericTypeIndicator_DataReference() {
    List<String> values = new ArrayList<>();
    values.add("Foo");
    values.add("Bar");

    GenericTypeIndicator<List<String>> typeIndicator =
            new GenericTypeIndicator<List<String>>() {
            };

    TestObserver<List<String>> sub = TestObserver.create();

    RxFirebaseDatabase.dataOf(mockDatabaseReference, typeIndicator)
            .subscribe(sub);

    verifyDataReferenceAddListenerForSingleValueEvent();
    callValueEventOnDataChange(typeIndicator, values);

    sub.assertComplete();
    sub.assertNoErrors();

    sub.assertValue(new Predicate<List<String>>() {
        @Override
        public boolean test(List<String> value) throws Exception {
            return "Foo".equals(value.get(0))
                    && "Bar".equals(value.get(1));
        }
    });

    sub.dispose();

    callValueEventOnDataChange(typeIndicator, values);

    // Ensure no more values are emitted after unsubscribe
    sub.assertValueCount(1);
}
 

@Test
public void testDataChangesOfGenericTypeIndicator_DataReference() {
    List<String> values = new ArrayList<>();
    values.add("Foo");
    values.add("Bar");

    GenericTypeIndicator<List<String>> typeIndicator =
            new GenericTypeIndicator<List<String>>() {
            };

    TestObserver<DataValue<List<String>>> sub = TestObserver.create();

    RxFirebaseDatabase.dataChangesOf(mockDatabaseReference, typeIndicator)
            .subscribe(sub);

    verifyDataReferenceAddValueEventListener();
    callValueEventOnDataChange(typeIndicator, values);

    sub.assertNotComplete();

    sub.assertValue(new Predicate<DataValue<List<String>>>() {
        @Override
        public boolean test(DataValue<List<String>> value) throws Exception {
            return value.isPresent()
                    && "Foo".equals(value.get().get(0))
                    && "Bar".equals(value.get().get(1));
        }
    });

    sub.dispose();

    callValueEventOnDataChange(typeIndicator, values);

    // Ensure no more values are emitted after unsubscribe
    sub.assertValueCount(1);
}
 

/**
 * @param query
 * @param typeIndicator
 * @param <T>
 * @return
 */
@NonNull
@CheckReturnValue
public static <T> Single<T> dataOf(
        @NonNull Query query, @NonNull GenericTypeIndicator<T> typeIndicator) {
    return data(query).compose(new SingleTransformerOfGenericTypeIndicator<T>(typeIndicator));
}
 

/**
 * @param ref
 * @param typeIndicator
 * @param <T>
 * @return
 */
@NonNull
@CheckReturnValue
public static <T> Single<T> dataOf(
        @NonNull DatabaseReference ref, @NonNull GenericTypeIndicator<T> typeIndicator) {
    return data(ref).compose(new SingleTransformerOfGenericTypeIndicator<T>(typeIndicator));
}
 

/**
 * @param query
 * @param typeIndicator
 * @param <T>
 * @return
 */
@NonNull
@CheckReturnValue
public static <T> Observable<DataValue<T>> dataChangesOf(
        @NonNull Query query, @NonNull GenericTypeIndicator<T> typeIndicator) {
    return dataChanges(query)
            .compose(new TransformerOfGenericTypeIndicator<T>(typeIndicator));
}
 

/**
 * @param ref
 * @param typeIndicator
 * @param <T>
 * @return
 */
@NonNull
@CheckReturnValue
public static <T> Observable<DataValue<T>> dataChangesOf(
        @NonNull DatabaseReference ref, @NonNull GenericTypeIndicator<T> typeIndicator) {
    return dataChanges(ref)
            .compose(new TransformerOfGenericTypeIndicator<T>(typeIndicator));
}
 

@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
    GenericTypeIndicator<HashMap<String, Cluster>> t = new GenericTypeIndicator<HashMap<String, Cluster>>() {
    };
    HashMap<String, Cluster> data = dataSnapshot.getValue(t);

    if (data != null) {
        clusters = new ArrayList<>(data.values());
        Collections.sort(clusters);
    }

    refresh();
}
 

public SingleTransformerOfGenericTypeIndicator(@NonNull GenericTypeIndicator<T> indicator) {
    this.typeIndicator = indicator;
}
 

public TransformerOfGenericTypeIndicator(@NonNull GenericTypeIndicator<T> indicator) {
    this.typeIndicator = indicator;
}
 

public GenericTypedDataSnapshotMapper(GenericTypeIndicator<U> genericTypeIndicator) {
    this.genericTypeIndicator = genericTypeIndicator;
}
 

public static <U> DataSnapshotMapper<DataSnapshot, U> of(GenericTypeIndicator<U> genericTypeIndicator) {
    return new GenericTypedDataSnapshotMapper<U>(genericTypeIndicator);
}