コード例 #1
0
ファイル: Uploader.java プロジェクト: 21347/android
  private void populateDirectoryList() {
    setContentView(R.layout.uploader_layout);

    String full_path = "";
    for (String a : mParents) full_path += a + "/";

    Log_OC.d(TAG, "Populating view with content of : " + full_path);

    mFile = mStorageManager.getFileByPath(full_path);
    if (mFile != null) {
      Vector<OCFile> files = mStorageManager.getFolderContent(mFile);
      List<HashMap<String, Object>> data = new LinkedList<HashMap<String, Object>>();
      for (OCFile f : files) {
        HashMap<String, Object> h = new HashMap<String, Object>();
        if (f.isFolder()) {
          h.put("dirname", f.getFileName());
          data.add(h);
        }
      }
      SimpleAdapter sa =
          new SimpleAdapter(
              this,
              data,
              R.layout.uploader_list_item_layout,
              new String[] {"dirname"},
              new int[] {R.id.textView1});
      setListAdapter(sa);
      Button btn = (Button) findViewById(R.id.uploader_choose_folder);
      btn.setOnClickListener(this);
      getListView().setOnItemClickListener(this);
    }
  }
コード例 #2
0
  /** Save new directory in local database */
  public void saveFolderInDB() {
    OCFile newDir = new OCFile(mRemotePath);
    newDir.setMimetype("DIR");
    long parentId =
        mStorageManager.getFileByPath(FileStorageUtils.getParentPath(mRemotePath)).getFileId();
    newDir.setParentId(parentId);
    newDir.setModificationTimestamp(System.currentTimeMillis());
    mStorageManager.saveFile(newDir);

    Log_OC.d(TAG, "Create directory " + mRemotePath + " in Database");
  }
コード例 #3
0
  /**
   * Performs the rename operation.
   *
   * @param client Client object to communicate with the remote ownCloud server.
   */
  @Override
  protected RemoteOperationResult run(OwnCloudClient client) {
    RemoteOperationResult result = null;

    // check if the new name is valid in the local file system
    try {
      if (!isValidNewName()) {
        return new RemoteOperationResult(ResultCode.INVALID_LOCAL_FILE_NAME);
      }
      String parent = (new File(mFile.getRemotePath())).getParent();
      parent = (parent.endsWith(OCFile.PATH_SEPARATOR)) ? parent : parent + OCFile.PATH_SEPARATOR;
      mNewRemotePath = parent + mNewName;
      if (mFile.isFolder()) {
        mNewRemotePath += OCFile.PATH_SEPARATOR;
      }

      // ckeck local overwrite
      if (mStorageManager.getFileByPath(mNewRemotePath) != null) {
        return new RemoteOperationResult(ResultCode.INVALID_OVERWRITE);
      }

      RenameRemoteFileOperation operation =
          new RenameRemoteFileOperation(
              mFile.getFileName(), mFile.getRemotePath(), mNewName, mFile.isFolder());
      result = operation.execute(client);

      if (result.isSuccess()) {
        if (mFile.isFolder()) {
          saveLocalDirectory();

        } else {
          saveLocalFile();
        }
      }

    } catch (IOException e) {
      Log_OC.e(
          TAG,
          "Rename "
              + mFile.getRemotePath()
              + " to "
              + ((mNewRemotePath == null) ? mNewName : mNewRemotePath)
              + ": "
              + ((result != null) ? result.getLogMessage() : ""),
          e);
    }

    return result;
  }
コード例 #4
0
ファイル: FileDetailFragment.java プロジェクト: MpApQ/android
    @Override
    public void onReceive(Context context, Intent intent) {
      String accountName = intent.getStringExtra(FileUploader.ACCOUNT_NAME);

      if (!isEmpty() && accountName.equals(mAccount.name)) {
        boolean uploadWasFine = intent.getBooleanExtra(FileUploader.EXTRA_UPLOAD_RESULT, false);
        String uploadRemotePath = intent.getStringExtra(FileUploader.EXTRA_REMOTE_PATH);
        if (mFile.getRemotePath().equals(uploadRemotePath)) {
          if (uploadWasFine) {
            FileDataStorageManager fdsm =
                new FileDataStorageManager(
                    mAccount, getActivity().getApplicationContext().getContentResolver());
            mFile = fdsm.getFileByPath(mFile.getRemotePath());
          }
          updateFileDetails(); // it updates the buttons; must be called although !uploadWasFine;
          // interrupted uploads still leave an incomplete file in the server
        }
      }
    }
コード例 #5
0
ファイル: FileUploader.java プロジェクト: kabushi/android
 private OCFile createLocalFolder(String remotePath) {
   String parentPath = new File(remotePath).getParent();
   parentPath =
       parentPath.endsWith(OCFile.PATH_SEPARATOR)
           ? parentPath
           : parentPath + OCFile.PATH_SEPARATOR;
   OCFile parent = mStorageManager.getFileByPath(parentPath);
   if (parent == null) {
     parent = createLocalFolder(parentPath);
   }
   if (parent != null) {
     OCFile createdFolder = new OCFile(remotePath);
     createdFolder.setMimetype("DIR");
     createdFolder.setParentId(parent.getFileId());
     mStorageManager.saveFile(createdFolder);
     return createdFolder;
   }
   return null;
 }
コード例 #6
0
  /**
   * Updates the view with all relevant details about that file.
   *
   * <p>TODO Remove parameter when the transferring state of files is kept in database.
   *
   * <p>TODO REFACTORING! this method called 5 times before every time the fragment is shown!
   *
   * @param transferring Flag signaling if the file should be considered as downloading or
   *     uploading, although {@link FileDownloaderBinder#isDownloading(Account, OCFile)} and {@link
   *     FileUploaderBinder#isUploading(Account, OCFile)} return false.
   * @param refresh If 'true', try to refresh the hold file from the database
   */
  public void updateFileDetails(boolean transferring, boolean refresh) {

    if (readyToShow()) {

      if (refresh && mStorageManager != null) {
        mFile = mStorageManager.getFileByPath(mFile.getRemotePath());
      }

      // set file details
      setFilename(mFile.getFileName());
      setFiletype(mFile.getMimetype());
      setFilesize(mFile.getFileLength());
      if (ocVersionSupportsTimeCreated()) {
        setTimeCreated(mFile.getCreationTimestamp());
      }

      setTimeModified(mFile.getModificationTimestamp());

      CheckBox cb = (CheckBox) getView().findViewById(R.id.fdKeepInSync);
      cb.setChecked(mFile.keepInSync());

      // configure UI for depending upon local state of the file
      // if (FileDownloader.isDownloading(mAccount, mFile.getRemotePath()) ||
      // FileUploader.isUploading(mAccount, mFile.getRemotePath())) {
      FileDownloaderBinder downloaderBinder = mContainerActivity.getFileDownloaderBinder();
      FileUploaderBinder uploaderBinder = mContainerActivity.getFileUploaderBinder();
      if (transferring
          || (downloaderBinder != null && downloaderBinder.isDownloading(mAccount, mFile))
          || (uploaderBinder != null && uploaderBinder.isUploading(mAccount, mFile))) {
        setButtonsForTransferring();

      } else if (mFile.isDown()) {

        setButtonsForDown();

      } else {
        // TODO load default preview image; when the local file is removed, the preview remains
        // there
        setButtonsForRemote();
      }
    }
    getView().invalidate();
  }
コード例 #7
0
ファイル: FileUploader.java プロジェクト: kabushi/android
 /**
  * Checks the existence of the folder where the current file will be uploaded both in the remote
  * server and in the local database.
  *
  * <p>If the upload is set to enforce the creation of the folder, the method tries to create it
  * both remote and locally.
  *
  * @param pathToGrant Full remote path whose existence will be granted.
  * @return An {@link OCFile} instance corresponding to the folder where the file will be uploaded.
  */
 private RemoteOperationResult grantFolderExistence(String pathToGrant) {
   RemoteOperation operation = new ExistenceCheckRemoteOperation(pathToGrant, this, false);
   RemoteOperationResult result = operation.execute(mUploadClient);
   if (!result.isSuccess()
       && result.getCode() == ResultCode.FILE_NOT_FOUND
       && mCurrentUpload.isRemoteFolderToBeCreated()) {
     operation = new CreateFolderOperation(pathToGrant, true, mStorageManager);
     result = operation.execute(mUploadClient);
   }
   if (result.isSuccess()) {
     OCFile parentDir = mStorageManager.getFileByPath(pathToGrant);
     if (parentDir == null) {
       parentDir = createLocalFolder(pathToGrant);
     }
     if (parentDir != null) {
       result = new RemoteOperationResult(ResultCode.OK);
     } else {
       result = new RemoteOperationResult(ResultCode.UNKNOWN_ERROR);
     }
   }
   return result;
 }
コード例 #8
0
ファイル: FileUploader.java プロジェクト: kabushi/android
  /**
   * Core upload method: sends the file(s) to upload
   *
   * @param uploadKey Key to access the upload to perform, contained in mPendingUploads
   */
  public void uploadFile(String uploadKey) {

    synchronized (mPendingUploads) {
      mCurrentUpload = mPendingUploads.get(uploadKey);
    }

    if (mCurrentUpload != null) {

      notifyUploadStart(mCurrentUpload);

      RemoteOperationResult uploadResult = null, grantResult = null;

      try {
        /// prepare client object to send requests to the ownCloud server
        if (mUploadClient == null || !mLastAccount.equals(mCurrentUpload.getAccount())) {
          mLastAccount = mCurrentUpload.getAccount();
          mStorageManager = new FileDataStorageManager(mLastAccount, getContentResolver());
          mUploadClient =
              OwnCloudClientFactory.createOwnCloudClient(mLastAccount, getApplicationContext());
        }

        /// check the existence of the parent folder for the file to upload
        String remoteParentPath = new File(mCurrentUpload.getRemotePath()).getParent();
        remoteParentPath =
            remoteParentPath.endsWith(OCFile.PATH_SEPARATOR)
                ? remoteParentPath
                : remoteParentPath + OCFile.PATH_SEPARATOR;
        grantResult = grantFolderExistence(remoteParentPath);

        /// perform the upload
        if (grantResult.isSuccess()) {
          OCFile parent = mStorageManager.getFileByPath(remoteParentPath);
          mCurrentUpload.getFile().setParentId(parent.getFileId());
          uploadResult = mCurrentUpload.execute(mUploadClient);
          if (uploadResult.isSuccess()) {
            saveUploadedFile();
          }
        } else {
          uploadResult = grantResult;
        }

      } catch (AccountsException e) {
        Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e);
        uploadResult = new RemoteOperationResult(e);

      } catch (IOException e) {
        Log_OC.e(TAG, "Error while trying to get autorization for " + mLastAccount.name, e);
        uploadResult = new RemoteOperationResult(e);

      } finally {
        synchronized (mPendingUploads) {
          mPendingUploads.remove(uploadKey);
          Log_OC.i(TAG, "Remove CurrentUploadItem from pending upload Item Map.");
        }
        if (uploadResult.isException()) {
          // enforce the creation of a new client object for next uploads; this grant that a new
          // socket will
          // be created in the future if the current exception is due to an abrupt lose of network
          // connection
          mUploadClient = null;
        }
      }

      /// notify result

      notifyUploadResult(uploadResult, mCurrentUpload);
      sendFinalBroadcast(mCurrentUpload, uploadResult);
    }
  }