Android app通过jcifs-ng实现Samba连接共享文件夹

Android端使用Samba连接共享文件夹，下载或上传文件的功能实现。如果你是用jcifs工具包，那么你要注意jcifs-ng 和 jcifs 支持的SMB版本区别。

JCIFS-NG的github地址
JCIFS官网地址 这里有关于jciffs、jcifs-codelibs、jcifs-ng、smbj的详细介绍

对比

• 支持的smb版本
  jcifs：
  仅支持SMB 1.0（CIFS）， jcifs 最初是针对 SMB 1.0（CIFS）协议开发的，因此它是对 SMB 1.0 版本的最好支持。
  jcifs-ng 2.1：
  此版本默认启用SMB2支持，并包含一些实验性的SMB3.0支持。
  协商的协议级别现在可以使用jcifs.smb.client.minVersion和jcifs.smb.client.maxVersion进行控制（这会弃用jcifs.smb.client.enableSMB2/jcifs.sm b.client.disableSMB1属性）。默认的最小/最大版本是SMB1到SMB210。
  此版本禁止服务器浏览（即服务器/工作组枚举），并包含有关身份验证的一些突破性API更改。
  jcifs-ng 2.0：
  此版本支持SMB2（2.02协议级别），目前仅在配置了jcifs.smb.client.enableSMB2的情况下宣布支持SMB2，但如果服务器不支持SMB1方言，也可以选择支持SMB2。

• 开发状态：
  jcifs： jcifs 是最初由 Mike Allen 开发的 Java CIFS 实现，最后一个官方发布版本是 1.3.19，发布于 2007 年。此后，jcifs 进入了维护模式，不再进行主要更新。
  jcifs-ng： jcifs-ng（jcifs-next generation）是基于 jcifs 的一个分支，由 Alexander Böhm 等人开发。它是对 jcifs 的改进和扩展，具有更现代化的代码结构和更多功能。jcifs-ng 目前仍在活跃地开发和维护。

• 功能和性能：
  jcifs-ng 在功能和性能上进行了改进和优化，相比于原始的 jcifs，它提供了更多的功能和更好的性能。例如，jcifs-ng 支持更多的 SMB 协议特性，并且在速度和稳定性方面进行了改进。

• API 和使用方式：
  jcifs-ng 在 API 和使用方式上与 jcifs 类似，但可能会有一些差异和改进。因此，如果你已经熟悉 jcifs，那么迁移到 jcifs-ng 应该相对容易。

这里使用的是jcifs-ng 2.1.9

添加依赖

implementation 'eu.agno3.jcifs:jcifs-ng:2.1.9'

代码实现（Kotlin）

package com.xxx.customer

import android.util.Log
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.lifecycleScope
import jcifs.CIFSContext
import jcifs.context.SingletonContext
import jcifs.smb.SmbException
import jcifs.smb.SmbFile
import jcifs.smb.SmbFileInputStream
import jcifs.smb.SmbFileOutputStream
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import java.io.BufferedInputStream
import java.io.BufferedOutputStream
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.io.IOException
import java.util.Properties


class SambaManager {

	private val SAMBA_SERVER_IP = "your server ip"
	private val SAMBA_USERNAME = "username"
	private val SAMBA_PASSWORD = "password"
	
    companion object {
        private const val TAG = "SambaManager"
        private var mCIFSContext: CIFSContext? = null

    }

    /**
     * 上传文件到共享文件夹指定目录
     * @param viewLifecycleOwner
     * @param localFilePathList 待上传的本地文件路径列表
     * @param remoteFolderPath 要上传到的远端路径，
     *        如果共享文件夹为shared_folder，则该路径应该包含shared_folder，
     *        如：shared_folder/ 或 shared_folder/xxx
     * @param onComplete 任务完成厚的回调
     */
    fun uploadFiles(
        viewLifecycleOwner: LifecycleOwner,
        localFilePathList: MutableList<String>,
        remoteFolderPath: String,
        onComplete: (Int) -> Unit
    ) {
        viewLifecycleOwner.lifecycleScope.launch(Dispatchers.IO) {
            var count = 0
            val smbContext = getCIFSContext()
            for (filePath in localFilePathList) {
                val localFile = File(filePath)
                if (!localFile.exists()) {
                    continue
                }
                val folderUrl = "smb://${SAMBA_SERVER_IP}/${remoteFolderPath.trim('/')}"
                val smbFolder = try {
                    SmbFile(folderUrl, smbContext)
                } catch (e: IOException) {
                    Log.e(TAG, "Failed to create SmbFile", e)
                    continue
                }
                //创建目录
                smbFolder.mkdirs()

                val url = "$folderUrl/${localFile.name}"
                val smbFile = try {
                    SmbFile(url, smbContext)
                } catch (e: IOException) {
                    Log.e(TAG, "Failed to create SmbFile", e)
                    continue
                }

                try {
                    if (smbFile.exists()) {
                        smbFile.delete()
                    }
                    smbFile.createNewFile()
                } catch (e: SmbException) {
                    Log.e(TAG, "Failed to create new SmbFile", e)
                    continue
                }

                try {
                    val outputStream = BufferedOutputStream(SmbFileOutputStream(smbFile))
                    val inputStream = BufferedInputStream(FileInputStream(localFile))
                    inputStream.use { input ->
                        outputStream.use { output ->
                            val buffer = ByteArray(1024)
                            var bytesRead: Int
                            while (input.read(buffer).also { bytesRead = it } != -1) {
                                output.write(buffer, 0, bytesRead)
                            }
                        }
                    }
                    count++
                } catch (e: IOException) {
                    Log.e(TAG, "Failed to download file", e)
                    continue
                }
            }
            onComplete(count)
        }
    }


    /**
     * 批量下载文件
     * @param viewLifecycleOwner
     * @param remoteFilePathList 需要下载的远端文件路径列表
     * @param localFolderPath 本地文件夹路径，用于保存下载的文件
     * @param onComplete 任务完成后的回调
     */
    fun downloadFiles(
        viewLifecycleOwner: LifecycleOwner,
        remoteFilePathList: MutableList<String>,
        localFolderPath: String,
        onComplete: (Int) -> Unit
    ) {
        viewLifecycleOwner.lifecycleScope.launch(Dispatchers.IO) {
            var count = 0

            val smbContext = getCIFSContext()

            for (path in remoteFilePathList) {
                val strList = path.split("/")
                var fileName = strList[strList.lastIndex]

                val url = "smb://${SAMBA_SERVER_IP}/${path.trimStart('/')}"
                val smbFile = try {
                    SmbFile(url, smbContext)
                } catch (e: IOException) {
                    Log.e(TAG, "Failed to create SmbFile", e)
                    continue
                }

                if (!smbFile.exists()) {
                    Log.e(TAG, "File does not exist: ${path}")
                    continue
                }

                try {
                    val localFile = File("$localFolderPath/$fileName")
                    if (!localFile.exists()) {
                        localFile.createNewFile()
                    }
                    val inputStream = BufferedInputStream(SmbFileInputStream(smbFile))
                    val outputStream = BufferedOutputStream(FileOutputStream(localFile))
                    inputStream.use { input ->
                        outputStream.use { output ->
                            val buffer = ByteArray(1024)
                            var bytesRead: Int
                            while (input.read(buffer).also { bytesRead = it } != -1) {
                                output.write(buffer, 0, bytesRead)
                            }
                        }
                    }
                    count++
                } catch (e: IOException) {
                    Log.e(TAG, "Failed to download file", e)
                    continue
                }
            }
            onComplete(count)
        }
    }

    /**
     * 获取包含配置参数的CIFSContext
     */
    private fun getCIFSContext(): CIFSContext {
        if (mCIFSContext == null) {
            val properties = Properties()
            properties.setProperty("jcifs.smb.client.domain", SAMBA_SERVER_IP);
            properties.setProperty("jcifs.smb.client.username", SAMBA_USERNAME);
            properties.setProperty("jcifs.smb.client.password", SAMBA_PASSWORD);
            SingletonContext.init(properties) //init只能初始化一次
            mCIFSContext = SingletonContext.getInstance()
        }
        return mCIFSContext!!
    }
}