package org.bigbluebutton.common.messages;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
public class Util {
public Map<String, Boolean> extractPermission(JsonObject vu) {
if (vu.has(Constants.PERM_DISABLE_CAM) && vu.has(Constants.PERM_DISABLE_MIC)
&& vu.has(Constants.PERM_DISABLE_PRIVCHAT) && vu.has(Constants.PERM_DISABLE_PUBCHAT)
&& vu.has(Constants.PERM_LOCKED_LAYOUT) && vu.has(Constants.PERM_LOCK_ON_JOIN)
&& vu.has(Constants.PERM_LOCK_ON_JOIN_CONFIG)){
Map<String, Boolean> vuMap = new HashMap<String, Boolean>();
Boolean disableCam = vu.get(Constants.PERM_DISABLE_CAM).getAsBoolean();
Boolean disableMic = vu.get(Constants.PERM_DISABLE_MIC).getAsBoolean();
Boolean disablePrivChat = vu.get(Constants.PERM_DISABLE_PRIVCHAT).getAsBoolean();
Boolean disablePubChat = vu.get(Constants.PERM_DISABLE_PUBCHAT).getAsBoolean();
Boolean lockedLayout = vu.get(Constants.PERM_LOCKED_LAYOUT).getAsBoolean();
Boolean lockOnJoin = vu.get(Constants.PERM_LOCK_ON_JOIN).getAsBoolean();
Boolean lockOnJoinConfig = vu.get(Constants.PERM_LOCK_ON_JOIN_CONFIG).getAsBoolean();
vuMap.put(Constants.PERM_DISABLE_CAM, disableCam);
vuMap.put(Constants.PERM_DISABLE_MIC, disableMic);
vuMap.put(Constants.PERM_DISABLE_PRIVCHAT, disablePrivChat);
vuMap.put(Constants.PERM_DISABLE_PUBCHAT, disablePubChat);
vuMap.put(Constants.PERM_LOCKED_LAYOUT, lockedLayout);
vuMap.put(Constants.PERM_LOCK_ON_JOIN, lockOnJoin);
vuMap.put(Constants.PERM_LOCK_ON_JOIN_CONFIG, lockOnJoinConfig);
return vuMap;
}
return null;
}
public Map<String, Object> extractVoiceUser(JsonObject vu) {
if (vu.has(Constants.TALKING) && vu.has(Constants.LOCKED)
&& vu.has(Constants.MUTED) && vu.has(Constants.JOINED)
&& vu.has(Constants.CALLERNAME) && vu.has(Constants.CALLERNUM)
&& vu.has(Constants.WEB_USERID) && vu.has(Constants.USER_ID)){
Map<String, Object> vuMap = new HashMap<String, Object>();
Boolean talking = vu.get(Constants.TALKING).getAsBoolean();
Boolean voiceLocked = vu.get(Constants.LOCKED).getAsBoolean();
Boolean muted = vu.get(Constants.MUTED).getAsBoolean();
Boolean joined = vu.get(Constants.JOINED).getAsBoolean();
String callername = vu.get(Constants.CALLERNAME).getAsString();
String callernum = vu.get(Constants.CALLERNUM).getAsString();
String webUserId = vu.get(Constants.WEB_USERID).getAsString();
String voiceUserId = vu.get(Constants.USER_ID).getAsString();
vuMap.put("talking", talking);
vuMap.put("locked", voiceLocked);
vuMap.put("muted", muted);
vuMap.put("joined", joined);
vuMap.put("callerName", callername);
vuMap.put("callerNum", callernum);
vuMap.put("webUserId", webUserId);
vuMap.put("userId", voiceUserId);
return vuMap;
}
return null;
}
public Map<String, Object> extractUser(JsonObject user) {
if (user.has(Constants.USER_ID) && user.has(Constants.NAME)
&& user.has(Constants.HAS_STREAM) && user.has(Constants.LISTENONLY)
&& user.has(Constants.EMOJI_STATUS) && user.has(Constants.PHONE_USER)
&& user.has(Constants.PRESENTER) && user.has(Constants.LOCKED)
&& user.has(Constants.EXTERN_USERID) && user.has(Constants.ROLE)
&& user.has(Constants.VOICEUSER) && user.has(Constants.WEBCAM_STREAM)){
Map<String, Object> userMap = new HashMap<String, Object>();
String userid = user.get(Constants.USER_ID).getAsString();
String username = user.get(Constants.NAME).getAsString();
Boolean hasStream = user.get(Constants.HAS_STREAM).getAsBoolean();
Boolean listenOnly = user.get(Constants.LISTENONLY).getAsBoolean();
String emojiStatus = user.get(Constants.EMOJI_STATUS).getAsString();
Boolean phoneUser = user.get(Constants.PHONE_USER).getAsBoolean();
Boolean presenter = user.get(Constants.PRESENTER).getAsBoolean();
Boolean locked = user.get(Constants.LOCKED).getAsBoolean();
String extUserId = user.get(Constants.EXTERN_USERID).getAsString();
String role = user.get(Constants.ROLE).getAsString();
String avatarURL = user.get(Constants.AVATAR_URL).getAsString();
JsonArray webcamStreamJArray = user.get(Constants.WEBCAM_STREAM).getAsJsonArray();
ArrayList<String> webcamStreams = extractWebcamStreams(webcamStreamJArray);
userMap.put("userId", userid);
userMap.put("name", username);
userMap.put("listenOnly", listenOnly);
userMap.put("hasStream", hasStream);
userMap.put("webcamStream", webcamStreams);
userMap.put("emojiStatus", emojiStatus);
userMap.put("externUserID", extUserId);
userMap.put("phoneUser", phoneUser);
userMap.put("locked", locked);
userMap.put("role", role);
userMap.put("presenter", presenter);
userMap.put("avatarURL", avatarURL);
JsonObject vu = (JsonObject) user.get(Constants.VOICEUSER);
Map<String, Object> vuMap = extractVoiceUser(vu);
if (vuMap != null) {
userMap.put("voiceUser", vuMap);
return userMap;
}
}
return null;
}
public ArrayList<String> extractStuns(JsonArray stunsArray) {
ArrayList<String> collection = new ArrayList<String>();
Iterator<JsonElement> stunIter = stunsArray.iterator();
while (stunIter.hasNext()) {
JsonElement aStun = stunIter.next();
if (aStun != null) {
collection.add(aStun.getAsString());
}
}
return collection;
}
public ArrayList<Map<String, Object>> extractTurns(JsonArray turnsArray) {
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> turnIter = turnsArray.iterator();
while (turnIter.hasNext()){
JsonElement aTurn = turnIter.next();
Map<String, Object> turnMap = extractATurn((JsonObject)aTurn);
if (turnMap != null) {
collection.add(turnMap);
}
}
return collection;
}
private Map<String,Object> extractATurn(JsonObject aTurn) {
if (aTurn.has(Constants.USERNAME)
&& aTurn.has(Constants.TTL)
&& aTurn.has(Constants.URL)
&& aTurn.has(Constants.PASSWORD)) {
Map<String, Object> turnMap = new HashMap<String, Object>();
turnMap.put(Constants.USERNAME, aTurn.get(Constants.USERNAME).getAsString());
turnMap.put(Constants.URL, aTurn.get(Constants.URL).getAsString());
turnMap.put(Constants.PASSWORD, aTurn.get(Constants.PASSWORD).getAsString());
turnMap.put(Constants.TTL, aTurn.get(Constants.TTL).getAsInt());
return turnMap;
}
return null;
}
public ArrayList<Map<String, Object>> extractChatHistory(JsonArray history) {
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> historyIter = history.iterator();
while (historyIter.hasNext()){
JsonElement chat = historyIter.next();
Map<String, Object> chatMap = extractChat((JsonObject)chat);
if (chatMap != null) {
collection.add(chatMap);
}
}
return collection;
}
private Map<String, Object> extractChat(JsonObject chat) {
if (chat.has(Constants.FROM_COLOR)
&& chat.has(Constants.MESSAGE)
&& chat.has(Constants.TO_USERNAME)
&& chat.has(Constants.FROM_TZ_OFFSET)
&& chat.has(Constants.FROM_COLOR)
&& chat.has(Constants.TO_USERID)
&& chat.has(Constants.FROM_USERID)
&& chat.has(Constants.FROM_TIME)
&& chat.has(Constants.FROM_USERNAME)){
Map<String, Object> chatMap = new HashMap<String, Object>();
chatMap.put(ChatKeyUtil.CHAT_TYPE, chat.get(Constants.CHAT_TYPE).getAsString());
chatMap.put(ChatKeyUtil.MESSAGE, chat.get(Constants.MESSAGE).getAsString());
chatMap.put(ChatKeyUtil.TO_USERNAME, chat.get(Constants.TO_USERNAME).getAsString());
chatMap.put(ChatKeyUtil.FROM_TZ_OFFSET, chat.get(Constants.FROM_TZ_OFFSET).getAsString());
chatMap.put(ChatKeyUtil.FROM_COLOR, chat.get(Constants.FROM_COLOR).getAsString());
chatMap.put(ChatKeyUtil.TO_USERID, chat.get(Constants.TO_USERID).getAsString());
chatMap.put(ChatKeyUtil.FROM_USERID, chat.get(Constants.FROM_USERID).getAsString());
chatMap.put(ChatKeyUtil.FROM_TIME, chat.get(Constants.FROM_TIME).getAsString());
chatMap.put(ChatKeyUtil.FROM_USERNAME, chat.get(Constants.FROM_USERNAME).getAsString());
return chatMap;
}
return null;
}
public ArrayList<Map<String, Object>> extractUsers(JsonArray users) {
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> usersIter = users.iterator();
while (usersIter.hasNext()){
JsonElement user = usersIter.next();
Map<String, Object> userMap = extractUser((JsonObject)user);
if (userMap != null) {
collection.add(userMap);
}
}
return collection;
}
public ArrayList<String> extractWebcamStreams(JsonArray webcamStreams) {
ArrayList<String> collection = new ArrayList<String>();
Iterator<JsonElement> webcamStreamsIter = webcamStreams.iterator();
while (webcamStreamsIter.hasNext()){
JsonElement stream = webcamStreamsIter.next();
collection.add(stream.getAsString());
}
return collection;
}
public ArrayList<String> extractUserids(JsonArray users) {
ArrayList<String> collection = new ArrayList<String>();
Iterator<JsonElement> usersIter = users.iterator();
while (usersIter.hasNext()){
JsonElement user = usersIter.next();
collection.add(user.getAsString());
}
return collection;
}
public Map<String, Object> extractAnnotation(JsonObject annotationElement) {
//NON-TEXT SHAPE
if (annotationElement.has(Constants.ID)
&& annotationElement.has("transparency")
&& annotationElement.has("color")
&& annotationElement.has("status")
&& annotationElement.has("whiteboardId")
&& annotationElement.has("type")
&& annotationElement.has("thickness")
&& annotationElement.has("points")){
Map<String, Object> finalAnnotation = new HashMap<String, Object>();
boolean transparency = annotationElement.get("transparency").getAsBoolean();
String id = annotationElement.get(Constants.ID).getAsString();
int color = annotationElement.get("color").getAsInt();
String status = annotationElement.get(Constants.STATUS).getAsString();
String whiteboardId = annotationElement.get("whiteboardId").getAsString();
int thickness = annotationElement.get("thickness").getAsInt();
String type = annotationElement.get("type").getAsString();
JsonArray pointsJsonArray = annotationElement.get("points").getAsJsonArray();
ArrayList<Float> pointsArray = new ArrayList<Float>();
Iterator<JsonElement> pointIter = pointsJsonArray.iterator();
while (pointIter.hasNext()){
JsonElement p = pointIter.next();
Float pf = p.getAsFloat();
if (pf != null) {
pointsArray.add(pf);
}
}
finalAnnotation.put("transparency", transparency);
finalAnnotation.put(Constants.ID, id);
finalAnnotation.put("color", color);
finalAnnotation.put("status", status);
finalAnnotation.put("whiteboardId", whiteboardId);
finalAnnotation.put("thickness", thickness);
finalAnnotation.put("points", pointsArray);
finalAnnotation.put("type", type);
return finalAnnotation;
}
// TEXT SHAPE
else if (annotationElement.has(Constants.ID)
&& annotationElement.has("text")
&& annotationElement.has("fontColor")
&& annotationElement.has("status")
&& annotationElement.has("textBoxWidth")
&& annotationElement.has("fontSize")
&& annotationElement.has("type")
&& annotationElement.has("calcedFontSize")
&& annotationElement.has("textBoxHeight")
&& annotationElement.has("calcedFontSize")
&& annotationElement.has("whiteboardId")
&& annotationElement.has("dataPoints")
&& annotationElement.has("x")
&& annotationElement.has("y")){
Map<String, Object> finalAnnotation = new HashMap<String, Object>();
String text = annotationElement.get("text").getAsString();
int fontColor = annotationElement.get("fontColor").getAsInt();
String status = annotationElement.get(Constants.STATUS).getAsString();
Float textBoxWidth = annotationElement.get("textBoxWidth").getAsFloat();
int fontSize = annotationElement.get("fontSize").getAsInt();
String type = annotationElement.get("type").getAsString();
Float calcedFontSize = annotationElement.get("calcedFontSize").getAsFloat();
Float textBoxHeight = annotationElement.get("textBoxHeight").getAsFloat();
String id = annotationElement.get(Constants.ID).getAsString();
String whiteboardId = annotationElement.get("whiteboardId").getAsString();
Float x = annotationElement.get("x").getAsFloat();
Float y = annotationElement.get("y").getAsFloat();
String dataPoints = annotationElement.get("dataPoints").getAsString();
finalAnnotation.put("text", text);
finalAnnotation.put("fontColor", fontColor);
finalAnnotation.put(Constants.STATUS, status);
finalAnnotation.put("textBoxWidth", textBoxWidth);
finalAnnotation.put("fontSize", fontSize);
finalAnnotation.put("type", type);
finalAnnotation.put("calcedFontSize", calcedFontSize);
finalAnnotation.put("textBoxHeight", textBoxHeight);
finalAnnotation.put(Constants.ID, id);
finalAnnotation.put("whiteboardId", whiteboardId);
finalAnnotation.put("x", x);
finalAnnotation.put("y", y);
finalAnnotation.put("dataPoints", dataPoints);
return finalAnnotation;
}
return null;
}
public Map<String, Object> extractCurrentPresenter(JsonObject vu) {
if (vu.has(Constants.USER_ID) && vu.has(Constants.NAME)
&& vu.has(Constants.ASSIGNED_BY)){
Map<String, Object> vuMap = new HashMap<String, Object>();
String presenterUserId = vu.get(Constants.USER_ID).getAsString();
String presenterName = vu.get(Constants.NAME).getAsString();
String assignedBy = vu.get(Constants.ASSIGNED_BY).getAsString();
vuMap.put("userId", presenterUserId);
vuMap.put("name", presenterName);
vuMap.put("assignedBy", assignedBy);
return vuMap;
}
return null;
}
public ArrayList<Map<String, Object>> extractPresentationPages(JsonArray pagesArray) {
ArrayList<Map<String, Object>> pages = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> pagesIter = pagesArray.iterator();
while (pagesIter.hasNext()){
JsonObject pageObj = (JsonObject)pagesIter.next();
if (pageObj.has("id") && pageObj.has("num")
&& pageObj.has("thumb_uri") && pageObj.has("swf_uri")
&& pageObj.has("txt_uri") && pageObj.has("svg_uri")
&& pageObj.has("current") && pageObj.has("x_offset")
&& pageObj.has("y_offset") && pageObj.has("width_ratio")
&& pageObj.has("height_ratio")) {
Map<String, Object> page = new HashMap<String, Object>();
String pageId = pageObj.get("id").getAsString();
Integer pageNum = pageObj.get("num").getAsInt();
String pageThumbUri = pageObj.get("thumb_uri").getAsString();
String pageSwfUri = pageObj.get("swf_uri").getAsString();
String pageTxtUri = pageObj.get("txt_uri").getAsString();
String pageSvgUri = pageObj.get("svg_uri").getAsString();
Boolean currentPage = pageObj.get("current").getAsBoolean();
Double xOffset = pageObj.get("x_offset").getAsDouble();
Double yOffset = pageObj.get("y_offset").getAsDouble();
Double widthRatio = pageObj.get("width_ratio").getAsDouble();
Double heightRatio = pageObj.get("height_ratio").getAsDouble();
page.put("id", pageId);
page.put("num", pageNum);
page.put("thumbUri", pageThumbUri);
page.put("swfUri", pageSwfUri);
page.put("txtUri", pageTxtUri);
page.put("svgUri", pageSvgUri);
page.put("current", currentPage);
page.put("xOffset", xOffset);
page.put("yOffset", yOffset);
page.put("widthRatio", widthRatio);
page.put("heightRatio", heightRatio);
pages.add(page);
}
}
return pages;
}
public ArrayList<Map<String, Object>> extractPresentations(JsonArray presArray) {
ArrayList<Map<String, Object>> presentations = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> presentationsIter = presArray.iterator();
while (presentationsIter.hasNext()){
JsonObject presObj = (JsonObject)presentationsIter.next();
presentations.add(extractPresentation(presObj));
}
return presentations;
}
public Map<String, Object> extractPresentation(JsonObject presObj) {
if (presObj.has(Constants.ID) && presObj.has(Constants.NAME)
&& presObj.has(Constants.CURRENT) && presObj.has(Constants.PAGES)) {
Map<String, Object> pres = new HashMap<String, Object>();
String presId = presObj.get(Constants.ID).getAsString();
String presName = presObj.get(Constants.NAME).getAsString();
Boolean currentPres = presObj.get(Constants.CURRENT).getAsBoolean();
pres.put("id", presId);
pres.put("name", presName);
pres.put("current", currentPres);
JsonArray pagesJsonArray = presObj.get(Constants.PAGES).getAsJsonArray();
ArrayList<Map<String, Object>> pages = extractPresentationPages(pagesJsonArray);
// store the pages in the presentation
pres.put(Constants.PAGES, pages);
// add this presentation into our presentations list
return pres;
}
return null;
}
public ArrayList<Map<String, Object>> extractShapes(JsonArray shapes) {
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> shapesIter = shapes.iterator();
while (shapesIter.hasNext()){
JsonElement shape = shapesIter.next();
Map<String, Object> shapeMap = extractOuterAnnotation((JsonObject)shape);
if (shapeMap != null) {
collection.add(shapeMap);
}
}
return collection;
}
public Map<String, Object> extractPollResultAnnotation(JsonObject annotationElement) {
if (annotationElement.has("result") && annotationElement.has("whiteboardId")
&& annotationElement.has("points")) {
Map<String, Object> finalAnnotation = new HashMap<String, Object>();
String whiteboardId = annotationElement.get("whiteboardId").getAsString();
Integer numRespondents = annotationElement.get(NUM_RESPONDENTS).getAsInt();
Integer numResponders = annotationElement.get(NUM_RESPONDERS).getAsInt();
String resultJson = annotationElement.get("result").getAsString();
JsonParser parser = new JsonParser();
JsonArray resultJsonArray = parser.parse(resultJson).getAsJsonArray();
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> resultIter = resultJsonArray.iterator();
while (resultIter.hasNext()){
JsonObject p = (JsonObject)resultIter.next();
Map<String, Object> vote = new HashMap<String, Object>();
Integer vid = p.get("id").getAsInt();
Integer vvotes = p.get("num_votes").getAsInt();
String vkey = p.get("key").getAsString();
vote.put("id", vid);
vote.put("num_votes", vvotes);
vote.put("key", vkey);
collection.add(vote);
}
JsonArray pointsJsonArray = annotationElement.get("points").getAsJsonArray();
ArrayList<Float> pointsArray = new ArrayList<Float>();
Iterator<JsonElement> pointIter = pointsJsonArray.iterator();
while (pointIter.hasNext()){
JsonElement p = pointIter.next();
Float pf = p.getAsFloat();
if (pf != null) {
pointsArray.add(pf);
}
}
finalAnnotation.put("whiteboardId", whiteboardId);
finalAnnotation.put(NUM_RESPONDENTS, numRespondents);
finalAnnotation.put(NUM_RESPONDERS, numResponders);
finalAnnotation.put("result", collection);
finalAnnotation.put("points", pointsArray);
return finalAnnotation;
}
return null;
}
public Map<String, Object> extractOuterAnnotation(JsonObject annotationElement) {
if (annotationElement.has(Constants.ID)
&& annotationElement.has("shape")
&& annotationElement.has("status")
&& annotationElement.has("shape_type")){
Map<String, Object> finalAnnotation = new HashMap<String, Object>();
String id = annotationElement.get(Constants.ID).getAsString();
String status = annotationElement.get("status").getAsString();
String type = annotationElement.get("shape_type").getAsString();
finalAnnotation.put(Constants.ID, id);
finalAnnotation.put("type", type);
finalAnnotation.put("status", status);
JsonElement shape = annotationElement.get("shape");
Map<String, Object> shapesMap;
if (type.equals("poll_result")) {
shapesMap = extractPollResultAnnotation((JsonObject)shape);
} else {
shapesMap = extractAnnotation((JsonObject)shape);
}
if (shapesMap != null) {
finalAnnotation.put("shapes", shapesMap);
}
return finalAnnotation;
}
return null;
}
public ArrayList<Map<String, Object>> extractPages(JsonArray pages) {
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> pagesIter = pages.iterator();
while (pagesIter.hasNext()){
JsonElement page = pagesIter.next();
Map<String, Object> pageMap = extractPage((JsonObject)page);
if (pageMap != null) {
collection.add(pageMap);
}
}
return collection;
}
public Map<String, Object> extractPage(JsonObject page) {
final String WIDTH_RATIO = "width_ratio";
final String Y_OFFSET = "y_offset";
final String NUM = "num";
final String HEIGHT_RATIO = "height_ratio";
final String X_OFFSET = "x_offset";
final String SVG_URI = "svg_uri";
final String THUMB_URI = "thumb_uri";
final String TXT_URI = "txt_uri";
final String CURRENT = "current";
final String SWF_URI = "swf_uri";
if (page.has(Constants.ID)
&& page.has(WIDTH_RATIO)
&& page.has(Y_OFFSET)
&& page.has(NUM)
&& page.has(HEIGHT_RATIO)
&& page.has(X_OFFSET)
&& page.has(SVG_URI)
&& page.has(THUMB_URI)
&& page.has(CURRENT)
&& page.has(TXT_URI)
&& page.has(SWF_URI)){
Map<String, Object> finalPage = new HashMap<String, Object>();
String id = page.get(Constants.ID).getAsString();
double widthRatio = page.get(WIDTH_RATIO).getAsDouble();
double yOffset = page.get(Y_OFFSET).getAsDouble();
double num = page.get(NUM).getAsDouble();
double heightRatio = page.get(HEIGHT_RATIO).getAsDouble();
double xOffset = page.get(X_OFFSET).getAsDouble();
String svgUri = page.get(SVG_URI).getAsString();
String thumbUri = page.get(THUMB_URI).getAsString();
boolean current = page.get(CURRENT).getAsBoolean();
String txtUri = page.get(TXT_URI).getAsString();
String swfUri = page.get(SWF_URI).getAsString();
finalPage.put(Constants.ID, id);
finalPage.put(WIDTH_RATIO, widthRatio);
finalPage.put(Y_OFFSET, yOffset);
finalPage.put(NUM, num);
finalPage.put(HEIGHT_RATIO, heightRatio);
finalPage.put(X_OFFSET, xOffset);
finalPage.put(SVG_URI, svgUri);
finalPage.put(THUMB_URI, thumbUri);
finalPage.put(CURRENT, current);
finalPage.put(TXT_URI, txtUri);
finalPage.put(SWF_URI, swfUri);
return finalPage;
}
return null;
}
public Map<String, Object> decodeSimplePollAnswer(JsonObject answer) {
Map<String, Object> answerMap = new HashMap<String, Object>();
if (answer.has(Constants.ID) && answer.has(KEY)) {
String id = answer.get(Constants.ID).getAsString();
String key = answer.get(KEY).getAsString();
answerMap.put(Constants.ID, id);
answerMap.put(KEY, key);
}
return answerMap;
}
public static final String ANSWERS = "answers";
public static final String KEY = "key";
public static final String NUM_VOTES = "num_votes";
public static final String NUM_RESPONDERS = "num_responders";
public static final String NUM_RESPONDENTS = "num_respondents";
public Map<String, Object> decodeSimplePoll(JsonObject poll) {
Map<String, Object> pollMap = new HashMap<String, Object>();
if (poll.has(Constants.ID) && poll.has(ANSWERS)) {
String id = poll.get(Constants.ID).getAsString();
JsonArray answers = poll.get(ANSWERS).getAsJsonArray();
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> answersIter = answers.iterator();
while (answersIter.hasNext()){
JsonElement qElem = answersIter.next();
Map<String, Object> answerMap = decodeSimplePollAnswer((JsonObject)qElem);
if (answerMap != null) {
collection.add(answerMap);
}
}
pollMap.put(Constants.ID, id);
pollMap.put(ANSWERS, collection);
}
return pollMap;
}
public Map<String, Object> decodeSimplePollAnswerVote(JsonObject answer) {
Map<String, Object> answerMap = new HashMap<String, Object>();
if (answer.has(Constants.ID) && answer.has(KEY)) {
String id = answer.get(Constants.ID).getAsString();
String key = answer.get(KEY).getAsString();
Integer numVotes = answer.get(NUM_VOTES).getAsInt();
answerMap.put(Constants.ID, id);
answerMap.put(KEY, key);
answerMap.put(NUM_VOTES, numVotes);
}
return answerMap;
}
public Map<String, Object> decodeSimplePollResult(JsonObject poll) {
Map<String, Object> pollMap = new HashMap<String, Object>();
if (poll.has(Constants.ID) && poll.has(ANSWERS)) {
String id = poll.get(Constants.ID).getAsString();
Integer numRespondents = poll.get(NUM_RESPONDENTS).getAsInt();
Integer numResponders = poll.get(NUM_RESPONDERS).getAsInt();
JsonArray answers = poll.get(ANSWERS).getAsJsonArray();
ArrayList<Map<String, Object>> collection = new ArrayList<Map<String, Object>>();
Iterator<JsonElement> answersIter = answers.iterator();
while (answersIter.hasNext()){
JsonElement qElem = answersIter.next();
Map<String, Object> answerMap = decodeSimplePollAnswerVote((JsonObject)qElem);
if (answerMap != null) {
collection.add(answerMap);
}
}
pollMap.put(Constants.ID, id);
pollMap.put(NUM_RESPONDENTS, numRespondents);
pollMap.put(NUM_RESPONDERS, numResponders);
pollMap.put(ANSWERS, collection);
}
return pollMap;
}
public Map<String, String[]> extractCaptionHistory(JsonObject history) {
Map<String, String[]> collection = new HashMap<String, String[]>();
for (Map.Entry<String,JsonElement> entry : history.entrySet()) {
String locale = entry.getKey();
JsonArray values = entry.getValue().getAsJsonArray();
String[] localeValueArray = new String[3];
int i = 0;
Iterator<JsonElement> valuesIter = values.iterator();
while (valuesIter.hasNext()){
String element = valuesIter.next().getAsString();
localeValueArray[i++] = element;
}
collection.put(locale, localeValueArray);
}
return collection;
}
}