ch.unifr.pai.twice.comm.serverPush.server.ServerRemoteEvent.java Source code

Introduction

Here is the source code for ch.unifr.pai.twice.comm.serverPush.server.ServerRemoteEvent.java

Source

package ch.unifr.pai.twice.comm.serverPush.server;

/*
 * Copyright 2013 Oliver Schmid
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.json.simple.parser.ContainerFactory;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

import ch.unifr.pai.twice.comm.serverPush.client.RemoteEvent;

/**
 * Server-side representation of a remote event including the required fields for further processing
 * 
 * @author Oliver Schmid
 * 
 */
public class ServerRemoteEvent implements Comparable<ServerRemoteEvent> {

    private final Object message;
    private String timeStamp;
    private String context;
    private String blockingEvent;
    private String type;
    private String originUUID;
    private List<String> receipients;

    public ServerRemoteEvent(Object message) {
        this.message = message;
        extract();
    }

    /**
     * @return true if it is a blocking event
     */
    public boolean isBlockingEvent() {
        return blockingEvent != null && blockingEvent.equals("1");
    }

    /**
     * update the object with the value of the JSON message
     */
    private void extract() {
        JSONParser parser = new JSONParser();
        ContainerFactory containerFactory = new ContainerFactory() {
            @Override
            public List<?> creatArrayContainer() {
                return new LinkedList();
            }

            @Override
            public Map createObjectContainer() {
                return new HashMap();
            }

        };

        try {
            Map json = (Map) parser.parse(message != null ? message.toString() : null, containerFactory);
            timeStamp = (String) json.get(RemoteEvent.TIMESTAMP);
            context = (String) json.get(RemoteEvent.CONTEXT);
            blockingEvent = (String) json.get(RemoteEvent.BLOCKINGEVENT);
            type = (String) json.get(RemoteEvent.EVENTTYPEKEY);
            originUUID = (String) json.get(RemoteEvent.ORIGINATINGDEVICE);
            receipients = (List<String>) json.get(RemoteEvent.RECEIPIENTS);

        } catch (ParseException pe) {
            System.out.println(pe);
        }
    }

    /**
     * @return the context identifier of the event
     */
    public String getContext() {
        return context;
    }

    /**
     * @return the timestamp of the event as string
     */
    public String getTimestamp() {
        return timeStamp;
    }

    /**
     * @return the type of the event as string
     */
    public String getType() {
        return type;
    }

    /**
     * @return the current delay between now and the timeStamp
     */
    public long getDelay() {
        if (timeStamp == null)
            return 0l;
        long delay = new Date().getTime() - Long.parseLong(timeStamp);
        if (delay < 0)
            return 0l;
        return delay;

    }

    /**
     * @return the timestamp as a long or null if it can not be parsed properly
     */
    public Long getTimestampAsLong() {
        try {
            return getTimestamp() == null ? null : Long.parseLong(getTimestamp());
        } catch (NumberFormatException e) {
            // It's not a valid timestamp, therefore it's null.
            return null;
        }
    }

    /**
     * @return the serialized message
     */
    public String getSerialized() {
        return message != null ? message.toString() : null;
    }

    /**
     * @return
     */
    public Object getMessage() {
        return message;
    }

    @Override
    public int compareTo(ServerRemoteEvent o) {
        return getTimestamp().compareTo(o.getTimestamp());
    }

    /**
     * @return the identifier of the originating device
     */
    public String getOriginUUID() {
        return originUUID;
    }

    /**
     * @return the unique identifiers of the receipients if there are some
     */
    public List<String> getReceipients() {
        return receipients;
    }
}