科创吧

public void testSftpListDir() {
        new UploadAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}

public static class UploadAsyncTask extends AsyncTask<Void, Void, Void> {
        private String TAG = "UploadAsyncTask";
        private long totalLen = 0;
        private long sendByteLen = 0;
        private long lastSendByteLen = 0;
        private String user = "himalayas";
        private String pwd = "1q2w3e4r5t";
        private String fileName = "a.txt";
        private boolean isExited = false;
        private String path = "ssh://himalayas:1q2w3e4r5t@10.168.66.1:22/bigdata/pullstashroot/ST202302230001007/test0";

        private CountDownTimer timer;

        public UploadAsyncTask() {
            timer = new CountDownTimer(1000 * 10000, 1000) {
                @Override
                public void onTick(long millisUntilFinished) {
                    Log.i(TAG, "ssh send speed:" + (sendByteLen - lastSendByteLen) + "(byte/s)");

                    lastSendByteLen = sendByteLen;
                }

                @Override
                public void onFinish() {
                    Log.i(TAG, "ssh send speed:" + (sendByteLen - lastSendByteLen) + "(byte/s)");
                    lastSendByteLen = sendByteLen;
                }
            };
            timer.start();
        }

        private void download() {
            CustomSshJConfig config = new CustomSshJConfig();
            SSHClient client = new SSHClient((Config) config);
            try {
                client.addHostKeyVerifier(new HostKeyVerifier() {
                    @Override
                    public boolean verify(String hostname, int port, PublicKey key) {
                        return true;
                    }

                    @Override
                    public List<String> findExistingAlgorithms(String hostname, int port) {
                        return null;
                    }
                });
                client.connect("10.168.66.1", 22);
                client.authPassword(user, pwd);

                SFTPClient sftp = client.newSFTPClient();
                String rootPath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "com.xinan.ubox.debug";
//    String srcPath = rootPath + "/de.apk";
//    String srcPath = rootPath + "/de.m4a";
//        String srcPath = rootPath + "/de.apk";
                String srcPath = rootPath + File.separator + fileName;
                String destPath = "/bigdata/test" + File.separator + fileName;
                final RemoteFile file = sftp.getSFTPEngine().open(destPath, EnumSet.of(OpenMode.CREAT, OpenMode.WRITE));
                OutputStream os = file.new RemoteFileOutputStream(0, 10) {
                    @Override
                    public void close() throws IOException {
                        try {
                            super.close();
                        } finally {
                            file.close();
                        }
                    }
                };

                totalLen = new File(srcPath).length();
                ReadableByteChannel inChannel = new RandomAccessFile(new File(srcPath), "r").getChannel();
                WritableByteChannel outChannel = Channels.newChannel(os);
                doCopy(inChannel, outChannel);

                inChannel.close();
                outChannel.close();

//        sftp.put(filePath, "/bigdata/test");
            } catch (UserAuthException e) {
                e.printStackTrace();
            } catch (TransportException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private void listFolder() {
            CustomSshJConfig config = new CustomSshJConfig();
            SSHClient client = new SSHClient((Config) config);
            try {
                client.addHostKeyVerifier(new HostKeyVerifier() {
                    @Override
                    public boolean verify(String hostname, int port, PublicKey key) {
                        return true;
                    }

                    @Override
                    public List<String> findExistingAlgorithms(String hostname, int port) {
                        return null;
                    }
                });
                client.connect("10.168.66.1", 22);
                client.authPassword(user, pwd);

                SFTPClient sftp = client.newSFTPClient();
                String rootPath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "com.xinan.ubox.debug";
                HybridFileParcelable fileParcelable = new HybridFileParcelable();
                fileParcelable.path = path;
                fileParcelable.isDirectory = true;
                List<HybridFileParcelable> sources = new ArrayList<>();
                sources.add(fileParcelable);
                _doListDir(sftp, sources, new OnFileFound() {
                    @Override
                    public void onFileFound(HybridFileParcelable file) {
                        Log.i(TAG, "onFileFound, name:" + file.name + " path:" + file.path + " dir:" + file.isDirectory + " size:" + file.size);
                    }

                    @Override
                    public void cancel() {

                    }
                });
            } catch (UserAuthException e) {
                e.printStackTrace();
            } catch (TransportException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private void _doListDir(SFTPClient sftp, List<HybridFileParcelable> sources, OnFileFound fileFound) {
            ArrayList<HybridFileParcelable> list = new ArrayList<>();
            for (HybridFileParcelable file: sources) {
                if (!file.isDirectory) {
                    continue;
                }

                String path = file.path;
                try {
                    for (RemoteResourceInfo info :
                            sftp.ls(extractRemotePathFrom(path))) {
                        boolean isDirectory = false;
                        try {
                            isDirectory = isDirectory(sftp, info);
                        } catch (IOException ifBrokenSymlink) {
                            Log.e(TAG, "IOException checking isDirectory(): " + info.getPath());
                            continue;
                        }
//                        Log.i(TAG, "path:" + path + " isDir:" + isDirectory + " info:" + info.getPath());

                        HybridFileParcelable fileParcelable = new HybridFileParcelable();
                        fileParcelable.path = String.format("%s/%s", path, info.getName());
                        fileParcelable.name = info.getName();
                        fileParcelable.isDirectory = isDirectory;
                        fileParcelable.size = isDirectory ? 0 : info.getAttributes().getSize();
                        if (isDirectory) {
                            list.add(fileParcelable);
                        } else {
                            fileFound.onFileFound(fileParcelable);
                        }
                    }
                } catch (IOException e) {
                    Log.e(TAG, "IOException", e);
                }
            }

            if (list.size() > 0) {
                _doListDir(sftp, list, fileFound);
            }
        }

        interface OnFileFound {
            void onFileFound(HybridFileParcelable file);
            void cancel();
        }

        public class HybridFileParcelable {
            private boolean isDirectory;
            public String path;
            public String name;
            public long date, size;
        }

        public boolean isDirectory(@NonNull SFTPClient client, @NonNull RemoteResourceInfo info)
                throws IOException {
            boolean isDirectory = info.isDirectory();
            if (info.getAttributes().getType().equals(FileMode.Type.SYMLINK)) {
                try {
                    FileAttributes symlinkAttrs = client.stat(info.getPath());
                    isDirectory = symlinkAttrs.getType().equals(FileMode.Type.DIRECTORY);
                } catch (IOException ifSymlinkIsBroken) {
                    Log.e(TAG, String.format("Symbolic link %s is broken, skipping", info.getPath()));
                    throw ifSymlinkIsBroken;
                }
            }
            return isDirectory;
        }

        public String extractRemotePathFrom(@NonNull String fullUri) {
            String hostPath = fullUri.substring(fullUri.indexOf('@'));
            return hostPath.indexOf('/') == -1 ? "/" : hostPath.substring(hostPath.indexOf('/'));
        }

        @Override
        protected Void doInBackground(Void... voids) {
            listFolder();

            return null;
        }

        @Override
        protected void onPostExecute(Void unused) {
            super.onPostExecute(unused);

            timer.cancel();
            Log.i(TAG, "upload file finish:" + sendByteLen + " totalLen:" + totalLen);
        }

        void doCopy(
                @NonNull ReadableByteChannel from,
                @NonNull WritableByteChannel to)
                throws IOException {
            final int DEFAULT_TRANSFER_QUANTUM = 65536;
            ByteBuffer buffer = ByteBuffer.allocateDirect(DEFAULT_TRANSFER_QUANTUM);
            long count = 0;

            while ((from.read(buffer) != -1 || buffer.position() > 0) && !isExited) {
                buffer.flip();
                count = to.write(buffer);

                sendByteLen += count;

                buffer.compact();
            }

            buffer.flip();
            while (buffer.hasRemaining()  && !isExited) {
                count = to.write(buffer);
//      Log.i("Copy", "buffer count:" + count);
                sendByteLen += count;
            }

            from.close();
            to.close();
        }
    }

    public static class CustomSshJConfig extends DefaultConfig {
        static {
            Security.removeProvider("BC");
            Security.insertProviderAt(new BouncyCastleProvider(), 0);
        }

        @Override
        protected void initCipherFactories() {
            List<Factory.Named<Cipher>> avail = new LinkedList<Factory.Named<Cipher>>(Arrays.<Factory.Named<Cipher>>asList(
                    StreamCiphers.Arcfour(),
                    BlockCiphers.BlowfishCBC(),
                    ChachaPolyCiphers.CHACHA_POLY_OPENSSH(),
                    BlockCiphers.AES128CBC(),
                    BlockCiphers.AES128CTR(),
                    BlockCiphers.AES192CBC(),
                    BlockCiphers.AES192CTR(),
                    BlockCiphers.AES256CBC(),
                    BlockCiphers.AES256CTR(),
                    GcmCiphers.AES128GCM(),
                    GcmCiphers.AES256GCM(),
                    BlockCiphers.BlowfishCTR(),
                    BlockCiphers.Cast128CBC(),
                    BlockCiphers.Cast128CTR(),
                    BlockCiphers.IDEACBC(),
                    BlockCiphers.IDEACTR(),
                    BlockCiphers.Serpent128CBC(),
                    BlockCiphers.Serpent128CTR(),
                    BlockCiphers.Serpent192CBC(),
                    BlockCiphers.Serpent192CTR(),
                    BlockCiphers.Serpent256CBC(),
                    BlockCiphers.Serpent256CTR(),
                    BlockCiphers.TripleDESCBC(),
                    BlockCiphers.TripleDESCTR(),
                    BlockCiphers.Twofish128CBC(),
                    BlockCiphers.Twofish128CTR(),
                    BlockCiphers.Twofish192CBC(),
                    BlockCiphers.Twofish192CTR(),
                    BlockCiphers.Twofish256CBC(),
                    BlockCiphers.Twofish256CTR(),
                    BlockCiphers.TwofishCBC(),
                    StreamCiphers.Arcfour128(),
                    StreamCiphers.Arcfour256())
            );

            boolean warn = false;
            // Ref. https://issues.apache.org/jira/browse/SSHD-24
            // "AES256 and AES192 requires unlimited cryptography extension"
            for (Iterator<Factory.Named<Cipher>> i = avail.iterator(); i.hasNext(); ) {
                final Factory.Named<Cipher> f = i.next();
                try {
                    final Cipher c = f.create();
                    final byte[] key = new byte[c.getBlockSize()];
                    final byte[] iv = new byte[c.getIVSize()];
                    c.init(Cipher.Mode.Encrypt, key, iv);
                } catch (Exception e) {
                    warn = true;
                    Log.e("CustomSshJConfig", e.getCause().getMessage());
                    i.remove();
                }
            }
            if (warn)
                Log.w("CustomSshJConfig", "Disabling high-strength ciphers: cipher strengths apparently limited by JCE policy");

            setCipherFactories(avail);
            Log.d("CustomSshJConfig", "Available cipher factories:" + avail);
        }
    }