@Override
  protected int uploadFile(OwnCloudClient client) throws HttpException, IOException {
    int status = -1;

    FileChannel channel = null;
    RandomAccessFile raf = null;
    try {
      File file = new File(mLocalPath);
      raf = new RandomAccessFile(file, "r");
      channel = raf.getChannel();
      mEntity = new ChunkFromFileChannelRequestEntity(channel, mMimeType, CHUNK_SIZE, file);
      // ((ProgressiveDataTransferer)mEntity).addDatatransferProgressListeners(getDataTransferListeners());
      synchronized (mDataTransferListeners) {
        ((ProgressiveDataTransferer) mEntity)
            .addDatatransferProgressListeners(mDataTransferListeners);
      }

      long offset = 0;
      String uriPrefix =
          client.getWebdavUri()
              + WebdavUtils.encodePath(mRemotePath)
              + "-chunking-"
              + Math.abs((new Random()).nextInt(9000) + 1000)
              + "-";
      long chunkCount = (long) Math.ceil((double) file.length() / CHUNK_SIZE);
      for (int chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++, offset += CHUNK_SIZE) {
        if (mPutMethod != null) {
          mPutMethod.releaseConnection(); // let the connection available for other methods
        }
        mPutMethod = new PutMethod(uriPrefix + chunkCount + "-" + chunkIndex);
        mPutMethod.addRequestHeader(OC_CHUNKED_HEADER, OC_CHUNKED_HEADER);
        ((ChunkFromFileChannelRequestEntity) mEntity).setOffset(offset);
        mPutMethod.setRequestEntity(mEntity);
        status = client.executeMethod(mPutMethod);
        client.exhaustResponse(mPutMethod.getResponseBodyAsStream());
        Log_OC.d(
            TAG,
            "Upload of "
                + mLocalPath
                + " to "
                + mRemotePath
                + ", chunk index "
                + chunkIndex
                + ", count "
                + chunkCount
                + ", HTTP result status "
                + status);
        if (!isSuccess(status)) break;
      }

    } finally {
      if (channel != null) channel.close();
      if (raf != null) raf.close();
      if (mPutMethod != null)
        mPutMethod.releaseConnection(); // let the connection available for other methods
    }
    return status;
  }
  /**
   * Check if a file exists in the OC server
   *
   * @deprecated Use ExistenceCheckOperation instead
   * @return 'true' if the file exists; 'false' it doesn't exist
   * @throws Exception When the existence could not be determined
   */
  @Deprecated
  public boolean existsFile(String path) throws IOException, HttpException {
    HeadMethod head = new HeadMethod(getWebdavUri() + WebdavUtils.encodePath(path));
    try {
      int status = executeMethod(head);
      Log_OC.d(
          TAG,
          "HEAD to "
              + path
              + " finished with HTTP status "
              + status
              + ((status != HttpStatus.SC_OK) ? "(FAIL)" : ""));
      exhaustResponse(head.getResponseBodyAsStream());
      return (status == HttpStatus.SC_OK);

    } finally {
      head.releaseConnection(); // let the connection available for other methods
    }
  }
  public void openFile(OCFile file) {
    if (file != null) {
      String storagePath = file.getStoragePath();
      String encodedStoragePath = WebdavUtils.encodePath(storagePath);

      Intent intentForSavedMimeType = new Intent(Intent.ACTION_VIEW);
      intentForSavedMimeType.setDataAndType(
          Uri.parse("file://" + encodedStoragePath), file.getMimetype());
      intentForSavedMimeType.setFlags(
          Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);

      Intent intentForGuessedMimeType = null;
      if (storagePath.lastIndexOf('.') >= 0) {
        String guessedMimeType =
            MimeTypeMap.getSingleton()
                .getMimeTypeFromExtension(storagePath.substring(storagePath.lastIndexOf('.') + 1));
        if (guessedMimeType != null && !guessedMimeType.equals(file.getMimetype())) {
          intentForGuessedMimeType = new Intent(Intent.ACTION_VIEW);
          intentForGuessedMimeType.setDataAndType(
              Uri.parse("file://" + encodedStoragePath), guessedMimeType);
          intentForGuessedMimeType.setFlags(
              Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        }
      }

      Intent chooserIntent;
      if (intentForGuessedMimeType != null) {
        chooserIntent =
            Intent.createChooser(
                intentForGuessedMimeType, mFileActivity.getString(R.string.actionbar_open_with));
      } else {
        chooserIntent =
            Intent.createChooser(
                intentForSavedMimeType, mFileActivity.getString(R.string.actionbar_open_with));
      }

      mFileActivity.startActivity(chooserIntent);

    } else {
      Log_OC.wtf(TAG, "Trying to open a NULL OCFile");
    }
  }
  public void sendDownloadedFile(OCFile file) {
    if (file != null) {
      String storagePath = file.getStoragePath();
      String encodedStoragePath = WebdavUtils.encodePath(storagePath);
      Intent sendIntent = new Intent(android.content.Intent.ACTION_SEND);
      // set MimeType
      sendIntent.setType(file.getMimetype());
      sendIntent.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://" + encodedStoragePath));
      sendIntent.putExtra(Intent.ACTION_SEND, true); // Send Action

      // Show dialog, without the own app
      String[] packagesToExclude = new String[] {mFileActivity.getPackageName()};
      DialogFragment chooserDialog =
          ShareLinkToDialog.newInstance(sendIntent, packagesToExclude, file);
      chooserDialog.show(mFileActivity.getSupportFragmentManager(), FTAG_CHOOSER_DIALOG);

    } else {
      Log_OC.wtf(TAG, "Trying to send a NULL OCFile");
    }
  }
  protected int downloadFile(OwnCloudClient client, File targetFile)
      throws HttpException, IOException, OperationCancelledException {
    int status = -1;
    boolean savedFile = false;
    mGet = new GetMethod(client.getWebdavUri() + WebdavUtils.encodePath(mRemotePath));
    Iterator<OnDatatransferProgressListener> it = null;

    FileOutputStream fos = null;
    try {
      status = client.executeMethod(mGet);
      if (isSuccess(status)) {
        targetFile.createNewFile();
        BufferedInputStream bis = new BufferedInputStream(mGet.getResponseBodyAsStream());
        fos = new FileOutputStream(targetFile);
        long transferred = 0;

        Header contentLength = mGet.getResponseHeader("Content-Length");
        long totalToTransfer =
            (contentLength != null && contentLength.getValue().length() > 0)
                ? Long.parseLong(contentLength.getValue())
                : 0;

        byte[] bytes = new byte[4096];
        int readResult = 0;
        while ((readResult = bis.read(bytes)) != -1) {
          synchronized (mCancellationRequested) {
            if (mCancellationRequested.get()) {
              mGet.abort();
              throw new OperationCancelledException();
            }
          }
          fos.write(bytes, 0, readResult);
          transferred += readResult;
          synchronized (mDataTransferListeners) {
            it = mDataTransferListeners.iterator();
            while (it.hasNext()) {
              it.next()
                  .onTransferProgress(
                      readResult, transferred, totalToTransfer, targetFile.getName());
            }
          }
        }
        if (transferred == totalToTransfer) { // Check if the file is completed
          savedFile = true;
          Header modificationTime = mGet.getResponseHeader("Last-Modified");
          if (modificationTime == null) {
            modificationTime = mGet.getResponseHeader("last-modified");
          }
          if (modificationTime != null) {
            Date d = WebdavUtils.parseResponseDate((String) modificationTime.getValue());
            mModificationTimestamp = (d != null) ? d.getTime() : 0;
          } else {
            Log_OC.e(
                TAG, "Could not read modification time from response downloading " + mRemotePath);
          }

          mEtag = WebdavUtils.getEtagFromResponse(mGet);
          if (mEtag.length() == 0) {
            Log_OC.e(TAG, "Could not read eTag from response downloading " + mRemotePath);
          }

        } else {
          client.exhaustResponse(mGet.getResponseBodyAsStream());
          // TODO some kind of error control!
        }

      } else {
        client.exhaustResponse(mGet.getResponseBodyAsStream());
      }

    } finally {
      if (fos != null) fos.close();
      if (!savedFile && targetFile.exists()) {
        targetFile.delete();
      }
      mGet.releaseConnection(); // let the connection available for other methods
    }
    return status;
  }