All files / src Message.js

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
108
109
110
111
112
113
114
115
116
117
118
119
120
 
 
 
 
 
 
 
 
 
 
1x
1x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
8x
 
 
 
2x
 
 
 
1x
 
 
 
 
 
 
 
7x
 
 
1x
 
6x
 
6x
 
6x
 
 
 
4x
 
 
1x
 
3x
 
 
 
1x
 
 
 
1x
 
 
 
 
 
 
 
 
1x
1x
4x
 
4x
2x
 
2x
2x
 
2x
2x
 
2x
2x
 
 
 
 
 
1x
1x
1x
1x
 
 
 
1x
1x
1x
1x
1x
 
 
 
1x
 
 
 
 
/**
 * @providesModule react-native-bridge-firebase/Message
 */
import Events from 'EventEmitter';
import forEach from 'lodash/forEach';
import debounce from 'lodash/debounce';
import omit from 'lodash/omit';
import RNBridgeFirebase from './RNBridgeFirebase';
import EventTypeError from './error/EventTypeError';
 
const { EventEmitter, EVENT, ERROR } = RNBridgeFirebase;
export const eventHandler = new Events();
 
export default class Message {
 
  static EVENT = EVENT;
 
  static ERROR = ERROR;
 
  static deviceInfo = {
    deviceToken: RNBridgeFirebase.deviceToken,
    firebaseToken: RNBridgeFirebase.firebaseToken,
    appVersion: RNBridgeFirebase.appVersion,
    deviceModel: RNBridgeFirebase.deviceModel,
    deviceName: RNBridgeFirebase.deviceName,
    deviceUid: RNBridgeFirebase.deviceUid,
  };
 
  constructor(parame: Object = {}) {
    forEach(parame, (value, key) => (this[key] = value));
  }
 
  static triggerEventRegistered = debounce(() => {
    eventHandler.emit(EVENT.REGISTERED, Message.deviceInfo);
  }, 3000);
 
  static async registerDevice() {
    await RNBridgeFirebase.registerDevice({
      alert: true,
      badge: true,
      sound: true,
    });
  }
 
  static addEventListener(type: String, handler: Function) {
    if (!(
      type === EVENT.REMOTE_NOTIFICATION ||
      type === EVENT.REGISTERED
    )) throw new EventTypeError('Message event only supports `REMOTE_NOTIFICATION` and `REGISTERED` events');
 
    const listener = eventHandler.addListener(type, handler);
 
    if (type === EVENT.REGISTERED) Message.triggerEventRegistered();
 
    return listener;
  }
 
  static removeEventListener(type: String, handler: Function = () => {}) {
    if (!(
      type === EVENT.REMOTE_NOTIFICATION ||
      type === EVENT.REGISTERED
    )) throw new EventTypeError('Message event only supports `REMOTE_NOTIFICATION` and `REGISTERED` events');
 
    eventHandler.removeListener(type, handler);
  }
 
  static subscribeToTopic(topic: String) {
    return RNBridgeFirebase.subscribeToTopic(topic);
  }
 
  static unsubscribeFromTopic(topic: String) {
    return RNBridgeFirebase.unsubscribeFromTopic(topic);
  }
 
  static notify(message: Object) {
    RNBridgeFirebase.notify(message);
  }
}
 
let lastMessageId;
Eif (EventEmitter) {
  EventEmitter.addListener(EVENT.REMOTE_NOTIFICATION, (data) => {
    const messageId = data['gcm.message_id'] || data['google.message_id'];
 
    if (lastMessageId === messageId) return;
    lastMessageId = messageId;
 
    const alert = data.aps && data.aps.alert;
    const notification = data.notification;
 
    const title = data.title || (alert && alert.title) || (notification && notification.title);
    const body = data.body || (alert && alert.body) || (notification && notification.body);
 
    const message = omit(data, ['gcm.message_id', 'google.message_id', 'aps', 'notification']);
    eventHandler.emit(
      EVENT.REMOTE_NOTIFICATION,
      new Message({ ...message, messageId, title, body }),
    );
  });
 
  EventEmitter.addListener(EVENT.DEVICE_REGISTERED, (data) => {
    Eif (data.deviceToken) {
      Message.deviceInfo.deviceToken = data.deviceToken;
      Message.triggerEventRegistered();
    }
  });
 
  EventEmitter.addListener(EVENT.REGISTERED, (data) => {
    Eif (data.firebaseToken) {
      RNBridgeFirebase.subscribeToTopic('/topics/all');
      Message.deviceInfo.firebaseToken = data.firebaseToken;
      Message.triggerEventRegistered();
    }
  });
 
  EventEmitter.addListener(EVENT.FAILED_TO_REGISTER, (data) => {
    console.log('error', data);
  });
}