src/eu/alefzero/owncloud/datamodel/OCFile.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012  Bartek Przybylski
   3  *
   4  *   This program is free software: you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License as published by
   6  *   the Free Software Foundation, either version 3 of the License, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details.
  13  *
  14  *   You should have received a copy of the GNU General Public License
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 package eu.alefzero.owncloud.datamodel;
  20
  21 import java.io.File;
  22
  23 import android.os.Parcel;
  24 import android.os.Parcelable;
  25
  26 public class OCFile implements Parcelable {
  27
  28         public static final Parcelable.Creator<OCFile> CREATOR = new Parcelable.Creator<OCFile>() {
  29                 @Override
  30                 public OCFile createFromParcel(Parcel source) {
  31                         return new OCFile(source);
  32                 }
  33
  34                 @Override
  35                 public OCFile[] newArray(int size) {
  36                         return new OCFile[size];
  37                 }
  38         };
  39
  40         private long mId;
  41         private long mParentId;
  42         private long mLength;
  43         private long mCreationTimestamp;
  44         private long mModifiedTimestamp;
  45         private String mRemotePath;
  46         private String mLocalPath;
  47         private String mMimeType;
  48         private boolean mNeedsUpdating;
  49
  50         /**
  51          * Create new {@link OCFile} with given path
  52          *
  53          * @param path
  54          *            The remote path of the file
  55          */
  56         public OCFile(String path) {
  57                 resetData();
  58                 mNeedsUpdating = false;
  59                 mRemotePath = path;
  60         }
  61
  62         /**
  63          * Reconstruct from parcel
  64          * @param source The source parcel
  65          */
  66         private OCFile(Parcel source){
  67                 mId = source.readLong();
  68                 mParentId = source.readLong();
  69                 mLength = source.readLong();
  70                 mCreationTimestamp = source.readLong();
  71                 mModifiedTimestamp = source.readLong();
  72                 mRemotePath = source.readString();
  73                 mLocalPath = source.readString();
  74                 mMimeType = source.readString();
  75                 mNeedsUpdating = source.readInt() == 0;
  76         }
  77
  78         /**
  79          * Gets the ID of the file
  80          *
  81          * @return the file ID
  82          */
  83         public long getFileId() {
  84                 return mId;
  85         }
  86
  87         /**
  88          * Returns the path of the file
  89          *
  90          * @return The path
  91          */
  92         public String getPath() {
  93                 return mRemotePath;
  94         }
  95
  96         /**
  97          * Can be used to check, whether or not this file exists in the database
  98          * already
  99          *
 100          * @return true, if the file exists in the database
 101          */
 102         public boolean fileExists() {
 103                 return mId != -1;
 104         }
 105
 106         /**
 107          * Use this to find out if this file is a Directory
 108          *
 109          * @return true if it is a directory
 110          */
 111         public boolean isDirectory() {
 112                 return mMimeType != null && mMimeType.equals("DIR");
 113         }
 114
 115         /**
 116          * Use this to check if this file is available locally
 117          *
 118          * @return true if it is
 119          */
 120         public boolean isDownloaded() {
 121                 return mLocalPath != null || mLocalPath.equals("");
 122         }
 123
 124         /**
 125          * The path, where the file is stored locally
 126          *
 127          * @return The local path to the file
 128          */
 129         public String getStoragePath() {
 130                 return mLocalPath;
 131         }
 132
 133         /**
 134          * Can be used to set the path where the file is stored
 135          *
 136          * @param storage_path
 137          *            to set
 138          */
 139         public void setStoragePath(String storage_path) {
 140                 mLocalPath = storage_path;
 141         }
 142
 143         /**
 144          * Get a UNIX timestamp of the file creation time
 145          *
 146          * @return A UNIX timestamp of the time that file was created
 147          */
 148         public long getCreationTimestamp() {
 149                 return mCreationTimestamp;
 150         }
 151
 152         /**
 153          * Set a UNIX timestamp of the time the file was created
 154          *
 155          * @param creation_timestamp
 156          *            to set
 157          */
 158         public void setCreationTimestamp(long creation_timestamp) {
 159                 mCreationTimestamp = creation_timestamp;
 160         }
 161
 162         /**
 163          * Get a UNIX timestamp of the file modification time
 164          *
 165          * @return A UNIX timestamp of the modification time
 166          */
 167         public long getModificationTimestamp() {
 168                 return mModifiedTimestamp;
 169         }
 170
 171         /**
 172          * Set a UNIX timestamp of the time the time the file was modified.
 173          *
 174          * @param modification_timestamp
 175          *            to set
 176          */
 177         public void setModificationTimestamp(long modification_timestamp) {
 178                 mModifiedTimestamp = modification_timestamp;
 179         }
 180
 181         /**
 182          * Returns the filename and "/" for the root directory
 183          *
 184          * @return The name of the file
 185          */
 186         public String getFileName() {
 187                 if (mRemotePath != null) {
 188                         File f = new File(mRemotePath);
 189                         return f.getName().equals("") ? "/" : f.getName();
 190                 }
 191                 return null;
 192         }
 193
 194         /**
 195          * Can be used to get the Mimetype
 196          *
 197          * @return the Mimetype as a String
 198          */
 199         public String getMimetype() {
 200                 return mMimeType;
 201         }
 202
 203         /**
 204          * Adds a file to this directory. If this file is not a directory, an
 205          * exception gets thrown.
 206          *
 207          * @param file
 208          *            to add
 209          * @throws IllegalStateException
 210          *             if you try to add a something and this is not a directory
 211          */
 212         public void addFile(OCFile file) throws IllegalStateException {
 213                 if (isDirectory()) {
 214                         file.mParentId = mId;
 215                         mNeedsUpdating = true;
 216                         return;
 217                 }
 218                 throw new IllegalStateException(
 219                                 "This is not a directory where you can add stuff to!");
 220         }
 221
 222         /**
 223          * Used internally. Reset all file properties
 224          */
 225         private void resetData() {
 226                 mId = -1;
 227                 mRemotePath = null;
 228                 mParentId = 0;
 229                 mLocalPath = null;
 230                 mMimeType = null;
 231                 mLength = 0;
 232                 mCreationTimestamp = 0;
 233                 mModifiedTimestamp = 0;
 234         }
 235
 236         /**
 237          * Sets the ID of the file
 238          *
 239          * @param file_id
 240          *            to set
 241          */
 242         public void setFileId(long file_id) {
 243                 mId = file_id;
 244         }
 245
 246         /**
 247          * Sets the Mime-Type of the
 248          *
 249          * @param mimetype
 250          *            to set
 251          */
 252         public void setMimetype(String mimetype) {
 253                 mMimeType = mimetype;
 254         }
 255
 256         /**
 257          * Sets the ID of the parent folder
 258          *
 259          * @param parent_id
 260          *            to set
 261          */
 262         public void setParentId(long parent_id) {
 263                 mParentId = parent_id;
 264         }
 265
 266         /**
 267          * Sets the file size in bytes
 268          *
 269          * @param file_len
 270          *            to set
 271          */
 272         public void setFileLength(long file_len) {
 273                 mLength = file_len;
 274         }
 275
 276         /**
 277          * Returns the size of the file in bytes
 278          *
 279          * @return The filesize in bytes
 280          */
 281         public long getFileLength() {
 282                 return mLength;
 283         }
 284
 285         /**
 286          * Returns the ID of the parent Folder
 287          *
 288          * @return The ID
 289          */
 290         public long getParentId() {
 291                 return mParentId;
 292         }
 293
 294         /**
 295          * Check, if this file needs updating
 296          *
 297          * @return
 298          */
 299         public boolean needsUpdatingWhileSaving() {
 300                 return mNeedsUpdating;
 301         }
 302
 303         @Override
 304         public int describeContents() {
 305                 return this.hashCode();
 306         }
 307
 308         @Override
 309         public void writeToParcel(Parcel dest, int flags) {
 310                 dest.writeLong(mId);
 311                 dest.writeLong(mParentId);
 312                 dest.writeLong(mLength);
 313                 dest.writeLong(mCreationTimestamp);
 314                 dest.writeLong(mModifiedTimestamp);
 315                 dest.writeString(mRemotePath);
 316                 dest.writeString(mLocalPath);
 317                 dest.writeString(mMimeType);
 318                 dest.writeInt(mNeedsUpdating ? 0 : 1 ); // No writeBoolean method exists - yay :D
 319         }
 320
 321 }