/// <include file='.\ISyncService.xml' path='/SyncService/Pull/*'/> public static SyncResult Pull(this ISyncService syncService, IEnumerable<FileEntry> entries, String localPath, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } // first we check the destination is a directory and exists DirectoryInfo d = new DirectoryInfo(localPath); if (!d.Exists) { return new SyncResult(ErrorCodeHelper.RESULT_NO_DIR_TARGET); } if (!d.IsDirectory()) { return new SyncResult(ErrorCodeHelper.RESULT_TARGET_IS_FILE); } // get a FileListingService object FileListingService fls = new FileListingService(syncService.Device); // compute the number of file to move long total = GetTotalRemoteFileSize(entries, fls); Log.i(TAG, "total transfer: {0}", total); // start the monitor monitor.Start(total); SyncResult result = syncService.DoPull(entries, localPath, fls, monitor); monitor.Stop(); return result; }
/// <summary> /// Push a single file. /// </summary> /// <param name="local">the local filepath.</param> /// <param name="remote">The remote filepath.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> public SyncResult PushFile(String local, String remote, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } FileInfo f = new FileInfo(local); if (!f.Exists) { return(new SyncResult(ErrorCodeHelper.RESULT_NO_LOCAL_FILE)); } if (f.IsDirectory( )) { return(new SyncResult(ErrorCodeHelper.RESULT_LOCAL_IS_DIRECTORY)); } monitor.Start(f.Length); SyncResult result = DoPushFile(local, remote, monitor); monitor.Stop( ); return(result); }
/// <summary> /// Pulls a single file. /// <para>Because this method just deals with a string for the remote file instead of FileEntry, /// the size of the file being pulled is unknown and the ISyncProgressMonitor will not properly /// show the progress</para> /// </summary> /// <param name="remoteFilepath">the full path to the remote file</param> /// <param name="localFilename">The local destination.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns>a SyncResult object with a code and an optional message.</returns> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> public SyncResult PullFile(string remoteFilepath, string localFilename, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } long totalWork = 0; try { FileListingService fls = new FileListingService(this.Device); FileEntry remoteFileEntry = fls.FindFileEntry(remoteFilepath); totalWork = remoteFileEntry.Size; } catch (FileNotFoundException ffe) { Log.W(TAG, ffe); } monitor.Start(totalWork); SyncResult result = DoPullFile(remoteFilepath, localFilename, monitor); monitor.Stop(); return(result); }
/// <summary> /// Push multiple files </summary> /// <param name="fileArray"> </param> /// <param name="remotePath"> </param> /// <param name="monitor"> /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPush(java.io.File[] fileArray, String remotePath, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException private void doPush(IEnumerable <string> fileArray, string remotePath, ISyncProgressMonitor monitor) { foreach (var f in fileArray) { // check if we're canceled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } if (Directory.Exists(f)) { // append the name of the directory to the remote path var name = Path.GetFileName(f); string dest = remotePath + "/" + name; // $NON-NLS-1S monitor.startSubTask(dest); doPush(Directory.GetFileSystemEntries(f), dest, monitor); monitor.advance(1); } else if (File.Exists(f)) { // append the name of the file to the remote path var name = Path.GetFileName(f); string remoteFile = remotePath + "/" + name; // $NON-NLS-1S monitor.startSubTask(remoteFile); doPushFile(f, remoteFile, monitor); } } }
/// <summary> /// Push several files. /// </summary> /// <param name="local">An array of local files to push</param> /// <param name="remote">the remote FileEntry representing a directory.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">Monitor cannot be null</exception> /// <gist id="380b3c149499bf31e49d" /> public SyncResult Push(IEnumerable <String> local, FileEntry remote, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } if (!remote.IsDirectory) { return(new SyncResult(ErrorCodeHelper.RESULT_REMOTE_IS_FILE)); } // make a list of File from the list of String List <FileSystemInfo> files = new List <FileSystemInfo> ( ); foreach (String path in local) { files.Add(path.GetFileSystemInfo( )); } // get the total count of the bytes to transfer long total = GetTotalLocalFileSize(files); monitor.Start(total); SyncResult result = DoPush(files, remote.FullPath, monitor); monitor.Stop( ); return(result); }
/// <summary> /// Pulls file(s) or folder(s). </summary> /// <param name="entries"> the remote item(s) to pull </param> /// <param name="localPath"> The local destination. If the entries count is > 1 or /// if the unique entry is a folder, this should be a folder. </param> /// <param name="monitor"> The progress monitor. Cannot be null. </param> /// <exception cref="SyncException"> </exception> /// <exception cref="IOException"> </exception> /// <exception cref="TimeoutException"> /// </exception> /// <seealso cref= FileListingService.FileEntry </seealso> /// <seealso cref= #getNullProgressMonitor() </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void pull(com.android.ddmlib.FileListingService.FileEntry[] entries, String localPath, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException public void pull(FileListingService.FileEntry[] entries, string localPath, ISyncProgressMonitor monitor) { // first we check the destination is a directory and exists if (!Directory.Exists(localPath)) { throw new SyncException(SyncException.SyncError.NO_DIR_TARGET); } if (File.Exists(localPath)) { throw new SyncException(SyncException.SyncError.TARGET_IS_FILE); } // get a FileListingService object FileListingService fls = new FileListingService(mDevice); // compute the number of file to move int total = getTotalRemoteFileSize(entries, fls); // start the monitor monitor.start(total); doPull(entries, localPath, fls, monitor); monitor.stop(); }
/// <include file='.\ISyncService.xml' path='/SyncService/Push/*'/> public static SyncResult Push(this ISyncService syncService, IEnumerable<String> local, FileEntry remote, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } if (!remote.IsDirectory) { return new SyncResult(ErrorCodeHelper.RESULT_REMOTE_IS_FILE); } // make a list of File from the list of String List<FileSystemInfo> files = new List<FileSystemInfo>(); foreach (String path in local) { files.Add(path.GetFileSystemInfo()); } // get the total count of the bytes to transfer long total = syncService.GetTotalLocalFileSize(files); monitor.Start(total); SyncResult result = syncService.DoPush(files, remote.FullPath, monitor); monitor.Stop(); return result; }
/// <include file='.\ISyncService.xml' path='/SyncService/PullFile/*'/> public static SyncResult PullFile(this ISyncService syncService, FileEntry remote, String localFilename, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } long total = remote.Size; monitor.Start(total); SyncResult result = syncService.DoPullFile(remote.FullPath, localFilename, monitor); monitor.Stop(); return result; }
/// <summary> /// Push several files. </summary> /// <param name="local"> An array of loca files to push </param> /// <param name="remote"> the remote <seealso cref="FileListingService.FileEntry"/> representing a directory. </param> /// <param name="monitor"> The progress monitor. Cannot be null. </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void push(String[] local, com.android.ddmlib.FileListingService.FileEntry remote, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException public void push(string[] local, FileListingService.FileEntry remote, ISyncProgressMonitor monitor) { if (remote.directory == false) { throw new SyncException(SyncException.SyncError.REMOTE_IS_FILE); } // get the total count of the bytes to transfer int total = getTotalLocalFileSize(local); monitor.start(total); doPush(local, remote.fullPath, monitor); monitor.stop(); }
/// <summary> /// Pulls a single file. /// </summary> /// <param name="remote">remote the remote file</param> /// <param name="localFilename">The local destination.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> /// <gist id="39fdc76b6f394b9bdf88" /> public SyncResult PullFile(FileEntry remote, String localFilename, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } long total = remote.Size; monitor.Start(total); SyncResult result = DoPullFile(remote.FullPath, localFilename, monitor); monitor.Stop( ); return(result); }
/// <include file='.\ISyncService.xml' path='/SyncService/PullFile2/*'/> public SyncResult PullFile(string remoteFilepath, string localFilename, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } long totalWork = 0; monitor.Start(totalWork); SyncResult result = this.DoPullFile(remoteFilepath, localFilename, monitor); monitor.Stop(); return(result); }
/// <summary> /// Push a single file. </summary> /// <param name="local"> the local filepath. </param> /// <param name="remote"> The remote filepath. </param> /// <param name="monitor"> The progress monitor. Cannot be null. /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void pushFile(String local, String remote, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException public void pushFile(string local, string remote, ISyncProgressMonitor monitor) { if (!File.Exists(local)) { throw new SyncException(SyncException.SyncError.NO_LOCAL_FILE); } if (Directory.Exists(local)) { throw new SyncException(SyncException.SyncError.LOCAL_IS_DIRECTORY); } monitor.start((int)new FileInfo(local).Length); doPushFile(local, remote, monitor); monitor.stop(); }
/// <summary> /// Pulls a single file. /// <p/>Because this method just deals with a String for the remote file instead of a /// <seealso cref="FileListingService.FileEntry"/>, the size of the file being pulled is unknown and the /// <seealso cref="ISyncProgressMonitor"/> will not properly show the progress </summary> /// <param name="remoteFilepath"> the full path to the remote file </param> /// <param name="localFilename"> The local destination. </param> /// <param name="monitor"> The progress monitor. Cannot be null. /// </param> /// <exception cref="IOException"> in case of an IO exception. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> /// <exception cref="SyncException"> in case of a sync exception. /// </exception> /// <seealso cref= #getNullProgressMonitor() </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void pullFile(String remoteFilepath, String localFilename, ISyncProgressMonitor monitor) throws TimeoutException, java.io.IOException, SyncException public void pullFile(string remoteFilepath, string localFilename, ISyncProgressMonitor monitor) { int?mode = readMode(remoteFilepath); if (mode == null) { // attempts to download anyway } else if (mode == 0) { throw new SyncException(SyncException.SyncError.NO_REMOTE_OBJECT); } monitor.start(0); //TODO: use the {@link FileListingService} to get the file size. doPullFile(remoteFilepath, localFilename, monitor); monitor.stop(); }
/// <summary> /// Pulls file(s) or folder(s). /// </summary> /// <param name="entries">the remote item(s) to pull</param> /// <param name="localPath">The local destination. If the entries count is > 1 or if the unique entry is a /// folder, this should be a folder.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <gist id="c9ca09c0c0779d0a5fb8" /> public SyncResult Pull(IEnumerable <FileEntry> entries, String localPath, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } // first we check the destination is a directory and exists DirectoryInfo d = new DirectoryInfo(localPath); if (!d.Exists) { return(new SyncResult(ErrorCodeHelper.RESULT_NO_DIR_TARGET)); } if (!d.IsDirectory()) { return(new SyncResult(ErrorCodeHelper.RESULT_TARGET_IS_FILE)); } // get a FileListingService object FileListingService fls = new FileListingService(Device); // compute the number of file to move long total = GetTotalRemoteFileSize(entries, fls); Log.d(TAG, "total transfer: {0}", total); // start the monitor monitor.Start(total); SyncResult result = DoPull(entries, localPath, fls, monitor); monitor.Stop( ); return(result); }
/// <summary> /// Pulls a remote file /// </summary> /// <param name="remotePath">the remote file (length max is 1024)</param> /// <param name="localPath">the local destination</param> /// <param name="monitor">the monitor. The monitor must be started already.</param> /// <returns>a SyncResult object with a code and an optional message.</returns> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> private SyncResult DoPullFile( string remotePath, string localPath, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } byte[] msg = null; byte[] pullResult = new byte[8]; int timeOut = DdmPreferences.Timeout; try { byte[] remotePathContent = remotePath.GetBytes ( AdbHelper.DEFAULT_ENCODING ); if ( remotePathContent.Length > REMOTE_PATH_MAX_LENGTH ) { return new SyncResult ( ErrorCodeHelper.RESULT_REMOTE_PATH_LENGTH ); } // create the full request message msg = CreateFileRequest ( RECV.GetBytes ( ), remotePathContent ); // and send it. AdbHelper.Instance.Write ( Channel, msg, -1, timeOut ); // read the result, in a byte array containing 2 ints // (id, size) AdbHelper.Instance.Read ( Channel, pullResult, -1, timeOut ); // check we have the proper data back if ( CheckResult ( pullResult, DATA.GetBytes ( ) ) == false && CheckResult ( pullResult, DONE.GetBytes ( ) ) == false ) { return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR ); } } catch ( EncoderFallbackException e ) { Console.WriteLine ( e ); return new SyncResult ( ErrorCodeHelper.RESULT_REMOTE_PATH_ENCODING, e ); } catch ( IOException e ) { Console.WriteLine ( e ); return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR, e ); } // access the destination file FileInfo f = new FileInfo ( localPath ); // create the stream to write in the file. We use a new try/catch block to differentiate // between file and network io exceptions. FileStream fos = null; try { fos = new FileStream ( f.FullName,System.IO.FileMode.Create,FileAccess.Write ); } catch ( FileNotFoundException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e ); } // the buffer to read the data byte[] data = new byte[SYNC_DATA_MAX]; using ( fos ) { // loop to get data until we're done. while ( true ) { // check if we're canceled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } // if we're done, we stop the loop if ( CheckResult ( pullResult, DONE.GetBytes ( ) ) ) { break; } if ( CheckResult ( pullResult, DATA.GetBytes ( ) ) == false ) { // hmm there's an error return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR ); } int length = pullResult.Swap32bitFromArray ( 4 ); if ( length > SYNC_DATA_MAX ) { // buffer overrun! // error and exit return new SyncResult ( ErrorCodeHelper.RESULT_BUFFER_OVERRUN ); } try { // now read the length we received AdbHelper.Instance.Read ( Channel, data, length, timeOut ); // get the header for the next packet. AdbHelper.Instance.Read ( Channel, pullResult, -1, timeOut ); } catch ( IOException e ) { Console.WriteLine ( e ); return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR, e ); } // write the content in the file try { fos.Write ( data, 0, length ); } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e ); } monitor.Advance ( length ); } try { fos.Flush ( ); } catch ( IOException e ) { Console.WriteLine ( e ); return new SyncResult ( ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e ); } } return new SyncResult ( ErrorCodeHelper.RESULT_OK ); }
/// <summary> /// /// </summary> /// <param name="entries"></param> /// <param name="localPath"></param> /// <param name="fls"></param> /// <param name="monitor"></param> /// <returns></returns> /// <exception cref="System.IO.IOException">Throws if unable to create a file or folder</exception> /// <exception cref="System.ArgumentNullException">Throws if the ISyncProgressMonitor is null</exception> private SyncResult DoPull( IEnumerable<FileEntry> entries, string localPath, FileListingService fileListingService, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } // check if we're cancelled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } // check if we need to create the local directory DirectoryInfo localDir = new DirectoryInfo ( localPath ); if ( !localDir.Exists ) { localDir.Create ( ); } foreach ( FileEntry e in entries ) { // check if we're canceled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } // the destination item (folder or file) String dest = Path.Combine ( localPath, e.Name ); // get type (we only pull directory and files for now) FileListingService.FileTypes type = e.Type; if ( type == FileListingService.FileTypes.Directory ) { monitor.StartSubTask ( e.FullPath, dest ); // then recursively call the content. Since we did a ls command // to get the number of files, we can use the cache FileEntry[] children = fileListingService.GetChildren ( e, true, null ); SyncResult result = DoPull ( children, dest, fileListingService, monitor ); if ( result.Code != ErrorCodeHelper.RESULT_OK ) { return result; } monitor.Advance ( 1 ); } else if ( type == FileListingService.FileTypes.File ) { monitor.StartSubTask ( e.FullPath, dest ); SyncResult result = DoPullFile ( e.FullPath, dest, monitor ); if ( result.Code != ErrorCodeHelper.RESULT_OK ) { return result; } } else if ( type == FileListingService.FileTypes.Link ) { monitor.StartSubTask ( e.FullPath, dest ); SyncResult result = DoPullFile ( e.FullResolvedPath, dest, monitor ); if ( result.Code != ErrorCodeHelper.RESULT_OK ) { return result; } } else { Log.d ( "ddms-sync", String.Format ( "unknown type to transfer: {0}", type ) ); } } return new SyncResult ( ErrorCodeHelper.RESULT_OK ); }
/// <summary> /// Push a single file. /// </summary> /// <param name="local">the local filepath.</param> /// <param name="remote">The remote filepath.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> public SyncResult PushFile( String local, String remote, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } FileInfo f = new FileInfo ( local ); if ( !f.Exists ) { return new SyncResult ( ErrorCodeHelper.RESULT_NO_LOCAL_FILE ); } if ( f.IsDirectory ( ) ) { return new SyncResult ( ErrorCodeHelper.RESULT_LOCAL_IS_DIRECTORY ); } monitor.Start ( f.Length ); SyncResult result = DoPushFile ( local, remote, monitor ); monitor.Stop ( ); return result; }
/// <summary> /// Pulls a single file. /// <para>Because this method just deals with a String for the remote file instead of FileEntry, /// the size of the file being pulled is unknown and the ISyncProgressMonitor will not properly /// show the progress</para> /// </summary> /// <param name="remoteFilepath">the full path to the remote file</param> /// <param name="localFilename">The local destination.</param> /// <param name="monitor">The progress monitor. Cannot be null.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> /// <gist id="9021e6c39ee20a6e122b" /> public SyncResult PullFile( String remoteFilepath, String localFilename, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } long totalWork = 0; try { FileListingService fls = new FileListingService ( this.Device ); FileEntry remoteFileEntry = fls.FindFileEntry ( remoteFilepath ); totalWork = remoteFileEntry.Size; } catch ( FileNotFoundException ffe ) { Console.WriteLine ( ffe.ToString ( ) ); Log.w ( "ddms", ffe ); } monitor.Start ( totalWork ); SyncResult result = DoPullFile ( remoteFilepath, localFilename, monitor ); monitor.Stop ( ); return result; }
/// <summary> /// Push a single file </summary> /// <param name="localPath"> the local file to push </param> /// <param name="remotePath"> the remote file (length max is 1024) </param> /// <param name="monitor"> the monitor. The monitor must be started already. /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPushFile(String localPath, String remotePath, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException private void doPushFile(string localPath, string remotePath, ISyncProgressMonitor monitor) { byte[] msg; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int timeOut = DdmPreferences.getTimeOut(); int timeOut = DdmPreferences.timeOut; try { var remotePathContent = remotePath.getBytes(AdbHelper.DEFAULT_ENCODING); if (remotePathContent.Length > REMOTE_PATH_MAX_LENGTH) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_LENGTH); } // create the header for the action //JAVA TO C# CONVERTER TODO TASK: Octal literals cannot be represented in C#: msg = createSendFileReq(ID_SEND, remotePathContent, 0644); } catch (ArgumentException e) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_ENCODING, e); } // create the stream to read the file using (var fis = File.OpenRead(localPath)) { // and send it. We use a custom try/catch block to make the difference between // file and network IO exceptions. AdbHelper.write(mChannel, msg, -1, timeOut); // create the buffer used to read. // we read max SYNC_DATA_MAX, but we need 2 4 bytes at the beginning. if (mBuffer == null) { mBuffer = new byte[SYNC_DATA_MAX + 8]; } Array.Copy(ID_DATA, 0, mBuffer, 0, ID_DATA.Length); // look while there is something to read while (true) { // check if we're canceled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } // read up to SYNC_DATA_MAX int readCount = fis.Read(mBuffer, 8, SYNC_DATA_MAX); if (readCount == -1) { // we reached the end of the file break; } // now send the data to the device // first write the amount read ArrayHelper.swap32bitsToArray(readCount, mBuffer, 4); // now write it AdbHelper.write(mChannel, mBuffer, readCount + 8, timeOut); // and advance the monitor monitor.advance(readCount); } } // create the DONE message long time = Environment.TickCount/1000; msg = createReq(ID_DONE, (int) time); // and send it. AdbHelper.write(mChannel, msg, -1, timeOut); // read the result, in a byte array containing 2 ints // (id, size) var result = new byte[8]; AdbHelper.read(mChannel, result, -1, timeOut); // full length if (checkResult(result, ID_OKAY) == false) { throw new SyncException(SyncException.SyncError.TRANSFER_PROTOCOL_ERROR, readErrorMessage(result, timeOut)); } }
/// <summary> /// Push multiple files </summary> /// <param name="fileArray"> </param> /// <param name="remotePath"> </param> /// <param name="monitor"> /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPush(java.io.File[] fileArray, String remotePath, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException private void doPush(IEnumerable<string> fileArray, string remotePath, ISyncProgressMonitor monitor) { foreach (var f in fileArray) { // check if we're canceled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } if (Directory.Exists(f)) { // append the name of the directory to the remote path var name = Path.GetFileName(f); string dest = remotePath + "/" + name; // $NON-NLS-1S monitor.startSubTask(dest); doPush(Directory.GetFileSystemEntries(f), dest, monitor); monitor.advance(1); } else if (File.Exists(f)) { // append the name of the file to the remote path var name = Path.GetFileName(f); string remoteFile = remotePath + "/" + name; // $NON-NLS-1S monitor.startSubTask(remoteFile); doPushFile(f, remoteFile, monitor); } } }
/// <summary> /// Pulls multiple files/folders recursively. </summary> /// <param name="entries"> The list of entry to pull </param> /// <param name="localPath"> the localpath to a directory </param> /// <param name="fileListingService"> a FileListingService object to browse through remote directories. </param> /// <param name="monitor"> the progress monitor. Must be started already. /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPull(com.android.ddmlib.FileListingService.FileEntry[] entries, String localPath, FileListingService fileListingService, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException private void doPull(FileListingService.FileEntry[] entries, string localPath, FileListingService fileListingService, ISyncProgressMonitor monitor) { foreach (FileListingService.FileEntry e in entries) { // check if we're cancelled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } // get type (we only pull directory and files for now) int type = e.type; if (type == FileListingService.TYPE_DIRECTORY) { monitor.startSubTask(e.fullPath); var dest = Path.Combine(localPath, e.name); // make the directory Directory.CreateDirectory(dest); // then recursively call the content. Since we did a ls command // to get the number of files, we can use the cache FileListingService.FileEntry[] children = fileListingService.getChildren(e, true, null); doPull(children, dest, fileListingService, monitor); monitor.advance(1); } else if (type == FileListingService.TYPE_FILE) { monitor.startSubTask(e.fullPath); string dest = Path.Combine(localPath, e.name); doPullFile(e.fullPath, dest, monitor); } } }
private SyncResult DoPush( IEnumerable<FileSystemInfo> files, string remotePath, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } // check if we're canceled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } foreach ( FileSystemInfo f in files ) { // check if we're canceled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } // append the name of the directory/file to the remote path String dest = LinuxPath.Combine ( remotePath, f.Name ); if ( f.Exists ) { if ( f.IsDirectory ( ) ) { DirectoryInfo fsiDir = f as DirectoryInfo; monitor.StartSubTask ( f.FullName, dest ); SyncResult result = DoPush ( fsiDir.GetFileSystemInfos ( ), dest, monitor ); if ( result.Code != ErrorCodeHelper.RESULT_OK ) { return result; } monitor.Advance ( 1 ); } else if ( f.IsFile ( ) ) { monitor.StartSubTask ( f.FullName, dest ); SyncResult result = DoPushFile ( f.FullName, dest, monitor ); if ( result.Code != ErrorCodeHelper.RESULT_OK ) { return result; } } } } return new SyncResult ( ErrorCodeHelper.RESULT_OK ); }
/// <include file='.\ISyncService.xml' path='/SyncService/PullFile2/*'/> public SyncResult PullFile(string remoteFilepath, string localFilename, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } long totalWork = 0; monitor.Start(totalWork); SyncResult result = this.DoPullFile(remoteFilepath, localFilename, monitor); monitor.Stop(); return result; }
/// <summary> /// Pulls a single file. </summary> /// <param name="remote"> the remote file </param> /// <param name="localFilename"> The local destination. </param> /// <param name="monitor"> The progress monitor. Cannot be null. /// </param> /// <exception cref="IOException"> in case of an IO exception. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> /// <exception cref="SyncException"> in case of a sync exception. /// </exception> /// <seealso cref= FileListingService.FileEntry </seealso> /// <seealso cref= #getNullProgressMonitor() </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void pullFile(com.android.ddmlib.FileListingService.FileEntry remote, String localFilename, ISyncProgressMonitor monitor) throws java.io.IOException, SyncException, TimeoutException public void pullFile(FileListingService.FileEntry remote, string localFilename, ISyncProgressMonitor monitor) { int total = remote.sizeValue; monitor.start(total); doPullFile(remote.fullPath, localFilename, monitor); monitor.stop(); }
/// <summary> /// Push a single file </summary> /// <param name="localPath"> the local file to push </param> /// <param name="remotePath"> the remote file (length max is 1024) </param> /// <param name="monitor"> the monitor. The monitor must be started already. /// </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPushFile(String localPath, String remotePath, ISyncProgressMonitor monitor) throws SyncException, java.io.IOException, TimeoutException private void doPushFile(string localPath, string remotePath, ISyncProgressMonitor monitor) { byte[] msg; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int timeOut = DdmPreferences.getTimeOut(); int timeOut = DdmPreferences.timeOut; try { var remotePathContent = remotePath.getBytes(AdbHelper.DEFAULT_ENCODING); if (remotePathContent.Length > REMOTE_PATH_MAX_LENGTH) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_LENGTH); } // create the header for the action //JAVA TO C# CONVERTER TODO TASK: Octal literals cannot be represented in C#: msg = createSendFileReq(ID_SEND, remotePathContent, 0644); } catch (ArgumentException e) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_ENCODING, e); } // create the stream to read the file using (var fis = File.OpenRead(localPath)) { // and send it. We use a custom try/catch block to make the difference between // file and network IO exceptions. AdbHelper.write(mChannel, msg, -1, timeOut); // create the buffer used to read. // we read max SYNC_DATA_MAX, but we need 2 4 bytes at the beginning. if (mBuffer == null) { mBuffer = new byte[SYNC_DATA_MAX + 8]; } Array.Copy(ID_DATA, 0, mBuffer, 0, ID_DATA.Length); // look while there is something to read while (true) { // check if we're canceled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } // read up to SYNC_DATA_MAX int readCount = fis.Read(mBuffer, 8, SYNC_DATA_MAX); if (readCount == -1) { // we reached the end of the file break; } // now send the data to the device // first write the amount read ArrayHelper.swap32bitsToArray(readCount, mBuffer, 4); // now write it AdbHelper.write(mChannel, mBuffer, readCount + 8, timeOut); // and advance the monitor monitor.advance(readCount); } } // create the DONE message long time = Environment.TickCount / 1000; msg = createReq(ID_DONE, (int)time); // and send it. AdbHelper.write(mChannel, msg, -1, timeOut); // read the result, in a byte array containing 2 ints // (id, size) var result = new byte[8]; AdbHelper.read(mChannel, result, -1, timeOut); // full length if (checkResult(result, ID_OKAY) == false) { throw new SyncException(SyncException.SyncError.TRANSFER_PROTOCOL_ERROR, readErrorMessage(result, timeOut)); } }
/// <summary> /// Pulls a remote file </summary> /// <param name="remotePath"> the remote file (length max is 1024) </param> /// <param name="localPath"> the local destination </param> /// <param name="monitor"> the monitor. The monitor must be started already. </param> /// <exception cref="SyncException"> if file could not be pushed </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doPullFile(String remotePath, String localPath, ISyncProgressMonitor monitor) throws java.io.IOException, SyncException, TimeoutException private void doPullFile(string remotePath, string localPath, ISyncProgressMonitor monitor) { var pullResult = new byte[8]; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int timeOut = DdmPreferences.getTimeOut(); int timeOut = DdmPreferences.timeOut; try { var remotePathContent = remotePath.getBytes(AdbHelper.DEFAULT_ENCODING); if (remotePathContent.Length > REMOTE_PATH_MAX_LENGTH) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_LENGTH); } // create the full request message var msg = createFileReq(ID_RECV, remotePathContent); // and send it. AdbHelper.write(mChannel, msg, -1, timeOut); // read the result, in a byte array containing 2 ints // (id, size) AdbHelper.read(mChannel, pullResult, -1, timeOut); // check we have the proper data back if (checkResult(pullResult, ID_DATA) == false && checkResult(pullResult, ID_DONE) == false) { throw new SyncException(SyncException.SyncError.TRANSFER_PROTOCOL_ERROR, readErrorMessage(pullResult, timeOut)); } } catch (ArgumentException e) { throw new SyncException(SyncException.SyncError.REMOTE_PATH_ENCODING, e); } // access the destination file // create the stream to write in the file. We use a new try/catch block to differentiate // between file and network io exceptions. FileStream fos = null; try { fos = File.Create(localPath); } catch (IOException e) { Log.e("ddms", string.Format("Failed to open local file {0} for writing, Reason: {1}", localPath, e)); throw new SyncException(SyncException.SyncError.FILE_WRITE_ERROR); } using (fos) { // the buffer to read the data var data = new byte[SYNC_DATA_MAX]; // loop to get data until we're done. while (true) { // check if we're cancelled if (monitor.canceled == true) { throw new SyncException(SyncException.SyncError.CANCELED); } // if we're done, we stop the loop if (checkResult(pullResult, ID_DONE)) { break; } if (checkResult(pullResult, ID_DATA) == false) { // hmm there's an error throw new SyncException(SyncException.SyncError.TRANSFER_PROTOCOL_ERROR, readErrorMessage(pullResult, timeOut)); } int length = ArrayHelper.swap32bitFromArray(pullResult, 4); if (length > SYNC_DATA_MAX) { // buffer overrun! // error and exit throw new SyncException(SyncException.SyncError.BUFFER_OVERRUN); } // now read the length we received AdbHelper.read(mChannel, data, length, timeOut); // get the header for the next packet. AdbHelper.read(mChannel, pullResult, -1, timeOut); // write the content in the file fos.Write(data, 0, length); monitor.advance(length); } fos.Flush(); } }
/// <summary> /// Push a single file /// </summary> /// <param name="local">the local file to push</param> /// <param name="remotePath">the remote file (length max is 1024)</param> /// <param name="monitor">the monitor. The monitor must be started already.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> private SyncResult DoPushFile( string local, string remotePath, ISyncProgressMonitor monitor ) { if ( monitor == null ) { throw new ArgumentNullException ( "monitor", "Monitor cannot be null" ); } FileStream fs = null; byte[] msg; int timeOut = DdmPreferences.Timeout; Console.WriteLine ( "Remote File: {0}", remotePath ); try { byte[] remotePathContent = remotePath.GetBytes ( AdbHelper.DEFAULT_ENCODING ); if ( remotePathContent.Length > REMOTE_PATH_MAX_LENGTH ) { return new SyncResult ( ErrorCodeHelper.RESULT_REMOTE_PATH_LENGTH ); } // this shouldn't happen but still... if ( !File.Exists ( local ) ) { return new SyncResult ( ErrorCodeHelper.RESULT_NO_LOCAL_FILE ); } // create the stream to read the file fs = new FileStream ( local, System.IO.FileMode.Open, FileAccess.Read ); // create the header for the action msg = CreateSendFileRequest ( SEND.GetBytes ( ), remotePathContent, (FileMode)0644 ); } catch ( EncoderFallbackException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_REMOTE_PATH_ENCODING, e ); } catch ( FileNotFoundException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_FILE_READ_ERROR, e ); } // and send it. We use a custom try/catch block to make the difference between // file and network IO exceptions. try { AdbHelper.Instance.Write ( Channel, msg, -1, timeOut ); } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR, e ); } // create the buffer used to read. // we read max SYNC_DATA_MAX, but we need 2 4 bytes at the beginning. if ( DataBuffer == null ) { DataBuffer = new byte[SYNC_DATA_MAX + 8]; } byte[] bDATA = DATA.GetBytes ( ); Array.Copy ( bDATA, 0, DataBuffer, 0, bDATA.Length ); // look while there is something to read while ( true ) { // check if we're canceled if ( monitor.IsCanceled ) { return new SyncResult ( ErrorCodeHelper.RESULT_CANCELED ); } // read up to SYNC_DATA_MAX int readCount = 0; try { readCount = fs.Read ( DataBuffer, 8, SYNC_DATA_MAX ); } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_FILE_READ_ERROR, e ); } if ( readCount == 0 ) { // we reached the end of the file break; } // now send the data to the device // first write the amount read readCount.Swap32bitsToArray(DataBuffer, 4); // now write it try { AdbHelper.Instance.Write ( Channel, DataBuffer, readCount + 8, timeOut ); } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR, e ); } // and advance the monitor monitor.Advance ( readCount ); } // close the local file try { fs.Close ( ); } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_FILE_READ_ERROR, e ); } try { // create the DONE message long time = DateTime.Now.CurrentTimeMillis ( ) / 1000; msg = CreateRequest ( DONE, (int)time ); // and send it. AdbHelper.Instance.Write ( Channel, msg, -1, timeOut ); // read the result, in a byte array containing 2 ints // (id, size) byte[] result = new byte[8]; AdbHelper.Instance.Read ( Channel, result, -1 /* full length */, timeOut ); if ( !CheckResult ( result, OKAY.GetBytes ( ) ) ) { if ( CheckResult ( result, FAIL.GetBytes ( ) ) ) { // read some error message... int len = result.Swap32bitFromArray ( 4 ); AdbHelper.Instance.Read ( Channel, DataBuffer, len, timeOut ); // output the result? String message = DataBuffer.GetString ( 0, len ); Log.e ( "ddms", "transfer error: " + message ); return new SyncResult ( ErrorCodeHelper.RESULT_UNKNOWN_ERROR, message ); } return new SyncResult ( ErrorCodeHelper.RESULT_UNKNOWN_ERROR ); } } catch ( IOException e ) { return new SyncResult ( ErrorCodeHelper.RESULT_CONNECTION_ERROR, e ); } // files pushed have no permissions... // lets check if we can get to the file... if(this.Device.FileSystem.Exists(remotePath)) { this.Device.FileSystem.Chmod(remotePath, "0666"); } return new SyncResult ( ErrorCodeHelper.RESULT_OK ); }
/// <summary> /// Push a single file /// </summary> /// <param name="local">the local file to push</param> /// <param name="remotePath">the remote file (length max is 1024)</param> /// <param name="monitor">the monitor. The monitor must be started already.</param> /// <returns> /// a SyncResult object with a code and an optional message. /// </returns> /// <exception cref="System.ArgumentNullException">monitor;Monitor cannot be null</exception> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> private SyncResult DoPushFile(string local, string remotePath, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } FileStream fs = null; byte[] msg; int timeOut = DdmPreferences.Timeout; Log.d(TAG, "Remote File: {0}", remotePath); try { byte[] remotePathContent = remotePath.GetBytes(AdbHelper.DEFAULT_ENCODING); if (remotePathContent.Length > REMOTE_PATH_MAX_LENGTH) { return(new SyncResult(ErrorCodeHelper.RESULT_REMOTE_PATH_LENGTH)); } // this shouldn't happen but still... if (!File.Exists(local)) { return(new SyncResult(ErrorCodeHelper.RESULT_NO_LOCAL_FILE)); } // create the stream to read the file fs = new FileStream(local, System.IO.FileMode.Open, FileAccess.Read); // create the header for the action msg = CreateSendFileRequest(SEND.GetBytes( ), remotePathContent, (FileMode)0644); } catch (EncoderFallbackException e) { return(new SyncResult(ErrorCodeHelper.RESULT_REMOTE_PATH_ENCODING, e)); } catch (FileNotFoundException e) { return(new SyncResult(ErrorCodeHelper.RESULT_FILE_READ_ERROR, e)); } // and send it. We use a custom try/catch block to make the difference between // file and network IO exceptions. try { AdbHelper.Instance.Write(Channel, msg, -1, timeOut); } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR, e)); } // create the buffer used to read. // we read max SYNC_DATA_MAX, but we need 2 4 bytes at the beginning. if (DataBuffer == null) { DataBuffer = new byte[SYNC_DATA_MAX + 8]; } byte[] bDATA = DATA.GetBytes( ); Array.Copy(bDATA, 0, DataBuffer, 0, bDATA.Length); // look while there is something to read while (true) { // check if we're canceled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } // read up to SYNC_DATA_MAX int readCount = 0; try { readCount = fs.Read(DataBuffer, 8, SYNC_DATA_MAX); } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_FILE_READ_ERROR, e)); } if (readCount == 0) { // we reached the end of the file break; } // now send the data to the device // first write the amount read readCount.Swap32bitsToArray(DataBuffer, 4); // now write it try { AdbHelper.Instance.Write(Channel, DataBuffer, readCount + 8, timeOut); } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR, e)); } // and advance the monitor monitor.Advance(readCount); } // close the local file try { fs.Close( ); } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_FILE_READ_ERROR, e)); } try { // create the DONE message long time = DateTime.Now.CurrentTimeMillis( ) / 1000; msg = CreateRequest(DONE, (int)time); // and send it. AdbHelper.Instance.Write(Channel, msg, -1, timeOut); // read the result, in a byte array containing 2 ints // (id, size) byte[] result = new byte[8]; AdbHelper.Instance.Read(Channel, result, -1 /* full length */, timeOut); if (!CheckResult(result, OKAY.GetBytes( ))) { if (CheckResult(result, FAIL.GetBytes( ))) { // read some error message... int len = result.Swap32bitFromArray(4); AdbHelper.Instance.Read(Channel, DataBuffer, len, timeOut); // output the result? String message = DataBuffer.GetString(0, len); Log.e("ddms", "transfer error: " + message); return(new SyncResult(ErrorCodeHelper.RESULT_UNKNOWN_ERROR, message)); } return(new SyncResult(ErrorCodeHelper.RESULT_UNKNOWN_ERROR)); } } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR, e)); } // files pushed have no permissions... // lets check if we can get to the file... if (this.Device.FileSystem.Exists(remotePath)) { this.Device.FileSystem.Chmod(remotePath, "0666"); } return(new SyncResult(ErrorCodeHelper.RESULT_OK)); }
/// <summary> /// Pulls a single file. /// <p/>Because this method just deals with a String for the remote file instead of a /// <seealso cref="FileListingService.FileEntry"/>, the size of the file being pulled is unknown and the /// <seealso cref="ISyncProgressMonitor"/> will not properly show the progress </summary> /// <param name="remoteFilepath"> the full path to the remote file </param> /// <param name="localFilename"> The local destination. </param> /// <param name="monitor"> The progress monitor. Cannot be null. /// </param> /// <exception cref="IOException"> in case of an IO exception. </exception> /// <exception cref="TimeoutException"> in case of a timeout reading responses from the device. </exception> /// <exception cref="SyncException"> in case of a sync exception. /// </exception> /// <seealso cref= #getNullProgressMonitor() </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void pullFile(String remoteFilepath, String localFilename, ISyncProgressMonitor monitor) throws TimeoutException, java.io.IOException, SyncException public void pullFile(string remoteFilepath, string localFilename, ISyncProgressMonitor monitor) { int? mode = readMode(remoteFilepath); if (mode == null) { // attempts to download anyway } else if (mode == 0) { throw new SyncException(SyncException.SyncError.NO_REMOTE_OBJECT); } monitor.start(0); //TODO: use the {@link FileListingService} to get the file size. doPullFile(remoteFilepath, localFilename, monitor); monitor.stop(); }
/// <summary> /// Pulls a remote file /// </summary> /// <param name="remotePath">the remote file (length max is 1024)</param> /// <param name="localPath">the local destination</param> /// <param name="monitor">the monitor. The monitor must be started already.</param> /// <returns>a SyncResult object with a code and an optional message.</returns> /// <exception cref="ArgumentNullException">Throws if monitor is null</exception> private SyncResult DoPullFile(string remotePath, string localPath, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } byte[] msg = null; byte[] pullResult = new byte[8]; int timeOut = DdmPreferences.Timeout; try { byte[] remotePathContent = remotePath.GetBytes(AdbHelper.DEFAULT_ENCODING); if (remotePathContent.Length > REMOTE_PATH_MAX_LENGTH) { return(new SyncResult(ErrorCodeHelper.RESULT_REMOTE_PATH_LENGTH)); } // create the full request message msg = CreateFileRequest(RECV.GetBytes( ), remotePathContent); // and send it. AdbHelper.Instance.Write(Channel, msg, -1, timeOut); // read the result, in a byte array containing 2 ints // (id, size) AdbHelper.Instance.Read(Channel, pullResult, -1, timeOut); // check we have the proper data back if (CheckResult(pullResult, DATA.GetBytes( )) == false && CheckResult(pullResult, DONE.GetBytes( )) == false) { return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR)); } } catch (EncoderFallbackException e) { Log.e(TAG, e); return(new SyncResult(ErrorCodeHelper.RESULT_REMOTE_PATH_ENCODING, e)); } catch (IOException e) { Log.e(TAG, e); return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR, e)); } // access the destination file FileInfo f = new FileInfo(localPath); // create the stream to write in the file. We use a new try/catch block to differentiate // between file and network io exceptions. FileStream fos = null; try { fos = new FileStream(f.FullName, System.IO.FileMode.Create, FileAccess.Write); } catch (FileNotFoundException e) { return(new SyncResult(ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e)); } // the buffer to read the data byte[] data = new byte[SYNC_DATA_MAX]; using ( fos ) { // loop to get data until we're done. while (true) { // check if we're canceled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } // if we're done, we stop the loop if (CheckResult(pullResult, DONE.GetBytes( ))) { break; } if (CheckResult(pullResult, DATA.GetBytes( )) == false) { // hmm there's an error return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR)); } int length = pullResult.Swap32bitFromArray(4); if (length > SYNC_DATA_MAX) { // buffer overrun! // error and exit return(new SyncResult(ErrorCodeHelper.RESULT_BUFFER_OVERRUN)); } try { // now read the length we received AdbHelper.Instance.Read(Channel, data, length, timeOut); // get the header for the next packet. AdbHelper.Instance.Read(Channel, pullResult, -1, timeOut); } catch (IOException e) { Log.e(TAG, e); return(new SyncResult(ErrorCodeHelper.RESULT_CONNECTION_ERROR, e)); } // write the content in the file try { fos.Write(data, 0, length); } catch (IOException e) { return(new SyncResult(ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e)); } monitor.Advance(length); } try { fos.Flush( ); } catch (IOException e) { Log.e(TAG, e); return(new SyncResult(ErrorCodeHelper.RESULT_FILE_WRITE_ERROR, e)); } } return(new SyncResult(ErrorCodeHelper.RESULT_OK)); }
private SyncResult DoPush(IEnumerable <FileSystemInfo> files, string remotePath, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } // check if we're canceled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } foreach (FileSystemInfo f in files) { // check if we're canceled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } // append the name of the directory/file to the remote path String dest = LinuxPath.Combine(remotePath, f.Name); if (f.Exists) { if (f.IsDirectory( )) { DirectoryInfo fsiDir = f as DirectoryInfo; monitor.StartSubTask(f.FullName, dest); SyncResult result = DoPush(fsiDir.GetFileSystemInfos( ), dest, monitor); if (result.Code != ErrorCodeHelper.RESULT_OK) { return(result); } monitor.Advance(1); } else if (f.IsFile( )) { monitor.StartSubTask(f.FullName, dest); SyncResult result = DoPushFile(f.FullName, dest, monitor); if (result.Code != ErrorCodeHelper.RESULT_OK) { return(result); } } } } return(new SyncResult(ErrorCodeHelper.RESULT_OK)); }
/// <summary> /// /// </summary> /// <param name="entries"></param> /// <param name="localPath"></param> /// <param name="fls"></param> /// <param name="monitor"></param> /// <returns></returns> /// <exception cref="System.IO.IOException">Throws if unable to create a file or folder</exception> /// <exception cref="System.ArgumentNullException">Throws if the ISyncProgressMonitor is null</exception> private SyncResult DoPull(IEnumerable <FileEntry> entries, string localPath, FileListingService fileListingService, ISyncProgressMonitor monitor) { if (monitor == null) { throw new ArgumentNullException("monitor", "Monitor cannot be null"); } // check if we're cancelled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } // check if we need to create the local directory DirectoryInfo localDir = new DirectoryInfo(localPath); if (!localDir.Exists) { localDir.Create( ); } foreach (FileEntry e in entries) { // check if we're canceled if (monitor.IsCanceled) { return(new SyncResult(ErrorCodeHelper.RESULT_CANCELED)); } // the destination item (folder or file) String dest = Path.Combine(localPath, e.Name); // get type (we only pull directory and files for now) FileListingService.FileTypes type = e.Type; if (type == FileListingService.FileTypes.Directory) { monitor.StartSubTask(e.FullPath, dest); // then recursively call the content. Since we did a ls command // to get the number of files, we can use the cache FileEntry[] children = fileListingService.GetChildren(e, true, null); SyncResult result = DoPull(children, dest, fileListingService, monitor); if (result.Code != ErrorCodeHelper.RESULT_OK) { return(result); } monitor.Advance(1); } else if (type == FileListingService.FileTypes.File) { monitor.StartSubTask(e.FullPath, dest); SyncResult result = DoPullFile(e.FullPath, dest, monitor); if (result.Code != ErrorCodeHelper.RESULT_OK) { return(result); } } else if (type == FileListingService.FileTypes.Link) { monitor.StartSubTask(e.FullPath, dest); SyncResult result = DoPullFile(e.FullResolvedPath, dest, monitor); if (result.Code != ErrorCodeHelper.RESULT_OK) { return(result); } } else { Log.d("ddms-sync", String.Format("unknown type to transfer: {0}", type)); } } return(new SyncResult(ErrorCodeHelper.RESULT_OK)); }