react-native-firestack/android/src/main/java/io/fullstack/firestack/FirestackUtils.java at feature/startAt · fullstackreact/react-native-firestack · GitHub

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
package io.fullstack.firestack;

import android.util.Log;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.facebook.react.bridge.ReactContext;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.ReadableMap;

import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMapKeySetIterator;
import com.facebook.react.bridge.ReadableType;

public class FirestackUtils {
  private static final String TAG = "FirestackUtils";

      // TODO NOTE
  public static void todoNote(final String tag, final String name, final Callback callback) {
    Log.e(tag, "The method " + name + " has not yet been implemented.");
    Log.e(tag, "Feel free to contribute to finish the method in the source.");

    WritableMap errorMap = Arguments.createMap();
    errorMap.putString("error", "unimplemented");
    callback.invoke(null, errorMap);
  }

  /**
  * send a JS event
  **/
  public static void sendEvent(final ReactContext context,
    String eventName,
    WritableMap params) {
      context
          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
          .emit(eventName, params);
  }

  public static Map<String, Object> recursivelyDeconstructReadableMap(ReadableMap readableMap) {
      ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
      Map<String, Object> deconstructedMap = new HashMap<>();
      while (iterator.hasNextKey()) {
          String key = iterator.nextKey();
          ReadableType type = readableMap.getType(key);
          switch (type) {
              case Null:
                  deconstructedMap.put(key, null);
                  break;
              case Boolean:
                  deconstructedMap.put(key, readableMap.getBoolean(key));
                  break;
              case Number:
                  deconstructedMap.put(key, readableMap.getDouble(key));
                  break;
              case String:
                  deconstructedMap.put(key, readableMap.getString(key));
                  break;
              case Map:
                  deconstructedMap.put(key, FirestackUtils.recursivelyDeconstructReadableMap(readableMap.getMap(key)));
                  break;
              case Array:
                  deconstructedMap.put(key, FirestackUtils.recursivelyDeconstructReadableArray(readableMap.getArray(key)));
                  break;
              default:
                  throw new IllegalArgumentException("Could not convert object with key: " + key + ".");
          }

      }
      return deconstructedMap;
  }

  public static List<Object> recursivelyDeconstructReadableArray(ReadableArray readableArray) {
      List<Object> deconstructedList = new ArrayList<>(readableArray.size());
      for (int i = 0; i < readableArray.size(); i++) {
          ReadableType indexType = readableArray.getType(i);
          switch(indexType) {
              case Null:
                  deconstructedList.add(i, null);
                  break;
              case Boolean:
                  deconstructedList.add(i, readableArray.getBoolean(i));
                  break;
              case Number:
                  deconstructedList.add(i, readableArray.getDouble(i));
                  break;
              case String:
                  deconstructedList.add(i, readableArray.getString(i));
                  break;
              case Map:
                  deconstructedList.add(i, FirestackUtils.recursivelyDeconstructReadableMap(readableArray.getMap(i)));
                  break;
              case Array:
                  deconstructedList.add(i, FirestackUtils.recursivelyDeconstructReadableArray(readableArray.getArray(i)));
                  break;
              default:
                  throw new IllegalArgumentException("Could not convert object at index " + i + ".");
          }
      }
      return deconstructedList;
  }
}