Files.java

Go to the documentation of this file.

/*
 *      Copyright (C) 2005-2013 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.call;

import android.os.Parcel;
import android.os.Parcelable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.node.ArrayNode;
import org.codehaus.jackson.node.ObjectNode;
import org.xbmc.android.jsonrpc.api.AbstractCall;
import org.xbmc.android.jsonrpc.api.AbstractModel;
import org.xbmc.android.jsonrpc.api.model.ListModel;

public final class Files {

        public static class GetDirectory extends AbstractCall<ListModel.FileItem> {
                public final static String API_TYPE = "Files.GetDirectory";

                @Override
                public void writeToParcel(Parcel parcel, int flags) {
                        super.writeToParcel(parcel, flags);
                        parcel.writeParcelable(mResult, flags);
                }

                protected GetDirectory(Parcel parcel) {
                        super(parcel);
                }

                public static final Parcelable.Creator<GetDirectory> CREATOR = new Parcelable.Creator<GetDirectory>() {
                        @Override
                        public GetDirectory createFromParcel(Parcel parcel) {
                                return new GetDirectory(parcel);
                        }
                        @Override
                        public GetDirectory[] newArray(int n) {
                                return new GetDirectory[n];
                        }
                };
                public final static String RESULT = "files";

                public GetDirectory(String directory, String media, ListModel.Sort sort, ListModel.Limits limits, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("media", media);
                        addParameter("sort", sort);
                        addParameter("limits", limits);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, String media, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("media", media);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, ListModel.Sort sort, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("sort", sort);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, String media, ListModel.Sort sort, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("media", media);
                        addParameter("sort", sort);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, ListModel.Limits limits, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("limits", limits);
                        addParameter("properties", properties);
                }

                public GetDirectory(String directory, ListModel.Sort sort, ListModel.Limits limits, String... properties) {
                        super();
                        addParameter("directory", directory);
                        addParameter("sort", sort);
                        addParameter("limits", limits);
                        addParameter("properties", properties);
                }

                @Override
                protected ArrayList<ListModel.FileItem> parseMany(JsonNode node) {
                        final ArrayNode files = parseResults(node, RESULT);
                        if (files != null) {
                                final ArrayList<ListModel.FileItem> ret = new ArrayList<ListModel.FileItem>(files.size());
                                for (int i = 0; i < files.size(); i++) {
                                        final ObjectNode item = (ObjectNode)files.get(i);
                                        ret.add(new ListModel.FileItem(item));
                                }
                                return ret;
                        } else {
                                return new ArrayList<ListModel.FileItem>(0);
                        }
                }

                @Override
                public String getName() {
                        return API_TYPE;
                }

                @Override
                protected boolean returnsList() {
                        return true;
                }
        }

        public static class GetFileDetails extends AbstractCall<ListModel.FileItem> {
                public final static String API_TYPE = "Files.GetFileDetails";

                @Override
                public void writeToParcel(Parcel parcel, int flags) {
                        super.writeToParcel(parcel, flags);
                        parcel.writeParcelable(mResult, flags);
                }

                protected GetFileDetails(Parcel parcel) {
                        super(parcel);
                }

                public static final Parcelable.Creator<GetFileDetails> CREATOR = new Parcelable.Creator<GetFileDetails>() {
                        @Override
                        public GetFileDetails createFromParcel(Parcel parcel) {
                                return new GetFileDetails(parcel);
                        }
                        @Override
                        public GetFileDetails[] newArray(int n) {
                                return new GetFileDetails[n];
                        }
                };
                public final static String RESULT = "filedetails";

                public GetFileDetails(String file, String media, String... properties) {
                        super();
                        addParameter("file", file);
                        addParameter("media", media);
                        addParameter("properties", properties);
                }

                public GetFileDetails(String file, String... properties) {
                        super();
                        addParameter("file", file);
                        addParameter("properties", properties);
                }

                @Override
                protected ListModel.FileItem parseOne(JsonNode node) {
                        return new ListModel.FileItem((ObjectNode)node.get(RESULT));
                }

                @Override
                public String getName() {
                        return API_TYPE;
                }

                @Override
                protected boolean returnsList() {
                        return false;
                }
        }

        public static class GetSources extends AbstractCall<ListModel.SourceItem> {
                public final static String API_TYPE = "Files.GetSources";

                @Override
                public void writeToParcel(Parcel parcel, int flags) {
                        super.writeToParcel(parcel, flags);
                        parcel.writeParcelable(mResult, flags);
                }

                protected GetSources(Parcel parcel) {
                        super(parcel);
                }

                public static final Parcelable.Creator<GetSources> CREATOR = new Parcelable.Creator<GetSources>() {
                        @Override
                        public GetSources createFromParcel(Parcel parcel) {
                                return new GetSources(parcel);
                        }
                        @Override
                        public GetSources[] newArray(int n) {
                                return new GetSources[n];
                        }
                };
                public final static String RESULT = "sources";

                public GetSources(String media, ListModel.Limits limits, ListModel.Sort sort) {
                        super();
                        addParameter("media", media);
                        addParameter("limits", limits);
                        addParameter("sort", sort);
                }

                public GetSources(String media) {
                        super();
                        addParameter("media", media);
                }

                public GetSources(String media, ListModel.Limits limits) {
                        super();
                        addParameter("media", media);
                        addParameter("limits", limits);
                }

                @Override
                protected ArrayList<ListModel.SourceItem> parseMany(JsonNode node) {
                        final ArrayNode sources = parseResults(node, RESULT);
                        if (sources != null) {
                                final ArrayList<ListModel.SourceItem> ret = new ArrayList<ListModel.SourceItem>(sources.size());
                                for (int i = 0; i < sources.size(); i++) {
                                        final ObjectNode item = (ObjectNode)sources.get(i);
                                        ret.add(new ListModel.SourceItem(item));
                                }
                                return ret;
                        } else {
                                return new ArrayList<ListModel.SourceItem>(0);
                        }
                }

                @Override
                public String getName() {
                        return API_TYPE;
                }

                @Override
                protected boolean returnsList() {
                        return true;
                }
        }

        public static class PrepareDownload extends AbstractCall<PrepareDownload.PrepareDownloadResult> {
                public final static String API_TYPE = "Files.PrepareDownload";

                @Override
                public void writeToParcel(Parcel parcel, int flags) {
                        super.writeToParcel(parcel, flags);
                        parcel.writeParcelable(mResult, flags);
                }

                protected PrepareDownload(Parcel parcel) {
                        super(parcel);
                }

                public static final Parcelable.Creator<PrepareDownload> CREATOR = new Parcelable.Creator<PrepareDownload>() {
                        @Override
                        public PrepareDownload createFromParcel(Parcel parcel) {
                                return new PrepareDownload(parcel);
                        }
                        @Override
                        public PrepareDownload[] newArray(int n) {
                                return new PrepareDownload[n];
                        }
                };

                public PrepareDownload(String path) {
                        super();
                        addParameter("path", path);
                }

                @Override
                protected PrepareDownloadResult parseOne(JsonNode node) {
                        return new PrepareDownloadResult(node);
                }

                @Override
                public String getName() {
                        return API_TYPE;
                }

                @Override
                protected boolean returnsList() {
                        return false;
                }

                public static class PrepareDownloadResult extends AbstractModel {

                        // field names
                        public static final String DETAILS = "details";
                        public static final String MODE = "mode";
                        public static final String PROTOCOL = "protocol";

                        // class members
                        public final String details;
                        public final String mode;
                        public final String protocol;

                        public PrepareDownloadResult(String details, String mode, String protocol) {
                                this.details = details;
                                this.mode = mode;
                                this.protocol = protocol;
                        }

                        public PrepareDownloadResult(JsonNode node) {
                                details = node.get(DETAILS).getTextValue(); // required value
                                mode = parseString(node, MODE);
                                protocol = parseString(node, PROTOCOL);
                        }

                        @Override
                        public JsonNode toJsonNode() {
                                final ObjectNode node = OM.createObjectNode();
                                node.put(DETAILS, details);
                                node.put(MODE, mode); // enum
                                node.put(PROTOCOL, protocol); // enum
                                return node;
                        }

                        static List<PrepareDownloadResult> getFilesPrepareDownloadResultList(JsonNode node, String key) {
                                if (node.has(key)) {
                                        final ArrayNode a = (ArrayNode)node.get(key);
                                        final List<PrepareDownloadResult> l = new ArrayList<PrepareDownloadResult>(a.size());
                                        for (int i = 0; i < a.size(); i++) {
                                                l.add(new PrepareDownloadResult((JsonNode)a.get(i)));
                                        }
                                        return l;
                                }
                                return new ArrayList<PrepareDownloadResult>(0);
                        }

                        @Override
                        public void writeToParcel(Parcel parcel, int flags) {
                                parcel.writeValue(details);
                                parcel.writeValue(mode); // enum
                                parcel.writeValue(protocol); // enum
                        }

                        protected PrepareDownloadResult(Parcel parcel) {
                                details = parcel.readString();
                                mode = parcel.readString(); // enum
                                protocol = parcel.readString(); // enum
                        }

                        public static final Parcelable.Creator<PrepareDownloadResult> CREATOR = new Parcelable.Creator<PrepareDownloadResult>() {
                                @Override
                                public PrepareDownloadResult createFromParcel(Parcel parcel) {
                                        return new PrepareDownloadResult(parcel);
                                }
                                @Override
                                public PrepareDownloadResult[] newArray(int n) {
                                        return new PrepareDownloadResult[n];
                                }
                        };

                        @Override
                        public int describeContents() {
                                return 0;
                        }

                        public interface Protocol {

                                public final String HTTP = "http";

                                public final static Set<String> values = new HashSet<String>(Arrays.asList(HTTP));
                        }

                        public interface Mode {

                                public final String REDIRECT = "redirect";
                                public final String DIRECT = "direct";

                                public final static Set<String> values = new HashSet<String>(Arrays.asList(REDIRECT, DIRECT));
                        }
                }
        }
}