FilesExpand file tree

master

/

example6.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

132 lines (115 loc) · 4.83 KB

master

/

example6.java

Copy path

Top

File metadata and controls

• Code
• Blame

132 lines (115 loc) · 4.83 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

121

122

123

124

125

126

127

128

129

130

131

132

import rx.Observable;

import rx.Subscriber;

import rx.functions.Action1;

import rx.functions.Func1;

import rx.functions.Func3;

import java.util.HashMap;

import java.util.Map;

/**

*

* This is a bit complex compared to the previous examples. In this one we

* have 3 asynchronous Observables that are emitting item(s). One of them

* uses flatMap() to transform the emitted item(s) from another into an Observable

* of its own.

*

* Then, uses zip() operator to combine all emitted Maps into one, and chains it

* with map() operator to format and obtain the needed data only.

*

* Remember to keep this kind of filtering to the operators and not in the

* subscriber's body as it's only responsible for listening/displaying/forwarding

* the data.

*

*/

public class example6 {

public static void main(String[] args){

getVideoForUser(47,27).subscribe(new Action1<Map>() {

@Override

public void call(Map map) {

System.out.println(map.get("movie-title"));

System.out.println(map.get("movie-language"));

System.out.println(map.get("movie-bookmark"));

}

});

}

private static Observable<Map> getVideoForUser(final int userId, final int videoId) {

Observable<Map> userObservable = getUserData(userId).map(new Func1<Map, Map>() {

@Override

public Map call(Map map) {

return map;

}

});

Observable<Map> bookmarkObservable = getVideoBookmark(userId, videoId).map(new Func1<Map, Map>() {

@Override

public Map call(Map map) {

return map;

}

});

Observable<Map> metaObservable = userObservable.flatMap(new Func1<Map, Observable<Map>>() {

@Override

public Observable<Map> call(Map map) {

return getVideoMetaData(videoId, (String) map.get("language"));

}

});

Observable<Map> finalObservable = Observable.zip(userObservable, bookmarkObservable, metaObservable, new Func3<Map, Map, Map, Map>() {

@Override

public Map<String, Map> call(Map userMap, Map bookmarkMap, Map metaMap) {

Map<String, Map> zipData = new HashMap<String, Map>();

zipData.put("user-map",userMap);

zipData.put("bookmark-map",bookmarkMap);

zipData.put("meta-map",metaMap);

return zipData;

}

}).map(data -> returnFinalDataForm(data));

return finalObservable;

}

private static Map returnFinalDataForm(Map<String,Map> data) {

Map<String, String> finalMap = new HashMap<String,String>();

finalMap.put("movie-title", (String)data.get("meta-map").get("videoTitle"));

finalMap.put("movie-language", (String)data.get("user-map").get("language"));

finalMap.put("movie-bookmark", (String)data.get("bookmark-map").get("position"));

return finalMap;

}

private static Observable<Map> getUserData(final int userId){

return Observable.create(new Observable.OnSubscribe<Map>() {

@Override

public void call(Subscriber<? super Map> subscriber) {

Map<String,String> userData = new HashMap<String, String>();

userData.put("userName","name");

userData.put("language","preferred language");

if(!subscriber.isUnsubscribed()){

subscriber.onNext(userData);

subscriber.onCompleted();

}

}

});

}

private static Observable<Map> getVideoBookmark(final int userId, final int videoId){

return Observable.create(new Observable.OnSubscribe<Map>() {

@Override

public void call(Subscriber<? super Map> subscriber) {

Map<String,String> videoData = new HashMap<String, String>();

videoData.put("position","0");

if(!subscriber.isUnsubscribed()){

subscriber.onNext(videoData);

subscriber.onCompleted();

}

}

});

}

private static Observable<Map> getVideoMetaData(final int videoId, final String language){

return Observable.create(new Observable.OnSubscribe<Map>() {

@Override

public void call(Subscriber<? super Map> subscriber) {

Map<String,String> videoMeta = new HashMap<String, String>();

videoMeta.put("videoId", videoId+"");

videoMeta.put("videoTitle","title");

videoMeta.put("videoDirector","director");

videoMeta.put("videoDuration","duration");

if(!subscriber.isUnsubscribed()){

subscriber.onNext(videoMeta);

subscriber.onCompleted();

}

}

});

}

}