AbstractCall.java

Go to the documentation of this file.

/*
 *      Copyright (C) 2005-2015 Team XBMC
 *      http://xbmc.org
 *
 *  This Program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  This Program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with XBMC Remote; see the file license.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */

package org.xbmc.android.jsonrpc.api;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ArrayNode;
import org.codehaus.jackson.node.NullNode;
import org.codehaus.jackson.node.ObjectNode;

import android.os.Parcel;
import android.os.Parcelable;
import android.util.Log;

public abstract class AbstractCall<T> implements Parcelable {
        
//      private static final String TAG = AbstractCall.class.getSimpleName();

        public static final String RESULT = "result";
        
        private final static Random RND = new Random(System.currentTimeMillis());
        protected final static ObjectMapper OM = new ObjectMapper();
        
        private static final String PARAMS = "params";
        
        public abstract String getName();

        protected abstract boolean returnsList();
        
        public ObjectNode mRequest = OM.createObjectNode();
        
        protected T mResult = null;
        protected ArrayList<T> mResults = null;
        
        private final String mId;
        
        protected AbstractCall() {
                final ObjectNode request = mRequest;
                
                mId = String.valueOf(RND.nextLong());
                request.put("jsonrpc", "2.0");
                request.put("id", mId);
                request.put("method", getName());
        }
        
        public ObjectNode getRequest() {
                return mRequest;
        }
        
        public void setResponse(JsonNode response) {
                if (returnsList()) {
                        mResults = parseMany(response.get(RESULT));
                } else {
                        mResult = parseOne(response.get(RESULT));
                }
        }
        
        @SuppressWarnings("unchecked")
        public void copyResponse(AbstractCall<?> call) {
                if (returnsList()) {
                        mResults = (ArrayList<T>)call.getResults();
                } else {
                        mResult = (T)call.getResult();
                }
        }
        
        public T getResult() {
                if (returnsList()) {
                        return mResults.get(0);
                }
                return mResult;
        }
        
        public ArrayList<T> getResults() {
                if (!returnsList()) {
                        final ArrayList<T> results = new ArrayList<T>(1);
                        results.add(mResult);
                        return results;
                }
                return mResults;
        }
        
        public String getId() {
                return mId;
        }
        
        protected JsonNode parseResult(JsonNode obj) {
                return obj.get(RESULT);
        }
        
        protected ArrayNode parseResults(JsonNode obj, String key) {
                if(obj.get(key) instanceof NullNode) {
                        return null;
                }
                return (ArrayNode)obj.get(key);
        }
        
        protected T parseOne(JsonNode obj) {
                return null;
        }
        
        protected ArrayList<T> parseMany(JsonNode obj) {
                return null;
        }
        
        protected void addParameter(String name, String value) {
                if (value != null) {
                        getParameters().put(name, value);
                }
        }
        
        protected void addParameter(String name, Integer value) {
                if (value != null) {
                        getParameters().put(name, value);
                }
        }
        
        protected void addParameter(String name, Boolean value) {
                if (value != null) {
                        getParameters().put(name, value);
                }
        }
        
        protected void addParameter(String name, Double value) {
                if (value != null) {
                        getParameters().put(name, value);
                }
        }
        
        protected void addParameter(String name, AbstractModel value) {
                if (value != null) {
                        getParameters().put(name, value.toJsonNode());
                }
        }
        
        protected void addParameter(String name, String[] values) {
                // don't add if nothing to add
                if (values == null || values.length == 0) {
                        return;
                }
                final ArrayNode props = OM.createArrayNode();
                for (int i = 0; i < values.length; i++) {
                        props.add(values[i]);
                }
                getParameters().put(name, props);
        }
        
        protected void addParameter(String name, HashMap<String, String> map) {
                if (map == null || map.size() == 0) {
                        return;
                }
                final ObjectNode props = OM.createObjectNode();
                for (String key : map.values()) {
                        props.put(key, map.get(key));
                }
                getParameters().put(name, props);
        }
        
        private ObjectNode getParameters() {
                final ObjectNode request = mRequest;
                if (request.has(PARAMS)) {
                        return (ObjectNode)request.get(PARAMS);
                } else {
                        final ObjectNode parameters = OM.createObjectNode();
                        request.put(PARAMS, parameters);
                        return parameters;
                }
        }
        
        @Override
        public void writeToParcel(Parcel parcel, int flags) {
                parcel.writeString(mId);
                parcel.writeValue(mRequest.toString());
        }
        @Override
        public int describeContents() {
                return 0;
        }
        
        protected AbstractCall(Parcel parcel) {
                mId = parcel.readString();
                try {
                        mRequest = (ObjectNode)OM.readTree(parcel.readString());
                } catch (JsonProcessingException e) {
                        Log.e(getName(), "Error reading JSON object from parcel: " + e.getMessage(), e);
                } catch (IOException e) {
                        Log.e(getName(), "I/O exception reading JSON object from parcel: " + e.getMessage(), e);
                }
        }
        
}