stability, continue from last dir, delete functionality with confirma…

…tion, upload functionality, show filename before sending bin or file upload

app/src/main/java/nyc/vonley/mi/di/network/MiFTPClient.kt

@@ -24,7 +24,7 @@ interface MiFTPClient : CoroutineScope, ProtocolCommandListener {
     suspend fun upload(file: String, byteArray: InputStream): Boolean
     suspend fun upload(file: String, byteArray: ByteArray): Boolean = upload(file, ByteArrayInputStream(byteArray))
     suspend fun upload(file: File): Boolean = upload(file.name, FileInputStream(file))
+    suspend fun delete(file: FTPFile): Boolean
     fun disconnect()
-    fun up()
 
 }

app/src/main/java/nyc/vonley/mi/di/network/SyncService.kt

@@ -29,4 +29,5 @@ interface SyncService: CoroutineScope {
     fun setTarget(client: Client)
     fun addConsoleListener(console: OnConsoleListener)
     fun stop()
+    fun removeConsoleListener(console: OnConsoleListener)
 }

app/src/main/java/nyc/vonley/mi/di/network/impl/MiFTPClientImpl.kt

@@ -8,16 +8,12 @@ import nyc.vonley.mi.BuildConfig
 import nyc.vonley.mi.di.annotations.SharedPreferenceStorage
 import nyc.vonley.mi.di.network.MiFTPClient
 import nyc.vonley.mi.utils.SharedPreferenceManager
-import nyc.vonley.mi.utils.get
-import okhttp3.internal.notify
+import nyc.vonley.mi.utils.set
 import okhttp3.internal.notifyAll
 import org.apache.commons.net.ProtocolCommandEvent
 import org.apache.commons.net.ftp.FTP
 import org.apache.commons.net.ftp.FTPClient
 import org.apache.commons.net.ftp.FTPFile
-import java.io.ByteArrayInputStream
-import java.io.File
-import java.io.FileInputStream
 import java.io.InputStream
 import javax.inject.Inject
 
@@ -29,6 +25,8 @@ class MiFTPClientImpl @Inject constructor(@SharedPreferenceStorage override val
     private val ftpPath get() = manager.ftpPath
     private val ftpUser get() = manager.ftpUser
     private val ftpPass get() = manager.ftpPass
+    private var _ip: String? = null
+    private var _port: Int? = null
 
     private val _cwd: MutableLiveData<Array<out FTPFile>> = MutableLiveData<Array<out FTPFile>>()
 
@@ -39,16 +37,34 @@ class MiFTPClientImpl @Inject constructor(@SharedPreferenceStorage override val
 
     private val callback = object : MiFTPEventListener {
 
-        override fun onLoggedIn() {
+        override fun onFailedToConnect() {
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, "Unable to connect")
+            }
+        }
 
+        override fun onLoggedIn() {
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, "User is logged in")
+            }
         }
 
         override fun onInvalidCredentials() {
-
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, "User entered invalid credentials")
+            }
         }
 
         override fun onDirChanged() {
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, "Directory Changed")
+            }
+        }
 
+        override fun isLoggedInAlready() {
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, "User is already logged in")
+            }
         }
 
     }
@@ -57,28 +73,53 @@ class MiFTPClientImpl @Inject constructor(@SharedPreferenceStorage override val
         fun onLoggedIn()
         fun onInvalidCredentials()
         fun onDirChanged()
+        fun isLoggedInAlready()
+        fun onFailedToConnect()
+    }
+
+    private suspend fun _connect(ip: String, port: Int) {
+        try {
+            client.connect(ip, port)
+            client.addProtocolCommandListener(this@MiFTPClientImpl)
+            val login = client.login(ftpUser, ftpPass)
+            if (login) {
+                setWorkingDir(ftpPath)
+                client.setFileType(FTP.BINARY_FILE_TYPE)
+                callback.onLoggedIn()
+            } else {
+                callback.onInvalidCredentials()
+            }
+        } catch (e: Throwable) {
+            if (BuildConfig.DEBUG) {
+                Log.e(TAG, e.message ?: "Something went wrong")
+            }
+            callback.onFailedToConnect()
+        }
     }
 
     override fun connect(ip: String, port: Int) {
-        if (!this::client.isInitialized) client = FTPClient()
+        if (!this::client.isInitialized) {
+            client = FTPClient()
+            _ip = ip
+            _port = port
+        }
         if (this::client.isInitialized) {
             if (client.isConnected) {
                 client.disconnect()
             }
-            client.addProtocolCommandListener(this)
             val block: suspend CoroutineScope.() -> Unit = {
-                client.connect(ip, port)
-                val login = client.login(ftpUser, ftpPass)
-                if (login) {
-                    setWorkingDir(ftpPath)
-                    client.setFileType(FTP.BINARY_FILE_TYPE)
-                    withContext(Dispatchers.Main) {
-                        callback.onLoggedIn()
+                if (client.isConnected) {
+                    if (_ip != ip || _port != port) {
+                        _ip = ip
+                        _port = port
+                        client.logout()
+                        client.disconnect()
+                        _connect(ip, port)
+                    } else {
+                        callback.isLoggedInAlready()
                     }
                 } else {
-                    withContext(Dispatchers.Main) {
-                        callback.onInvalidCredentials()
-                    }
+                    _connect(ip, port)
                 }
             }
             launch(block = block)
@@ -94,28 +135,28 @@ class MiFTPClientImpl @Inject constructor(@SharedPreferenceStorage override val
     }
 
     override fun setWorkingDir(dir: String?) {
-        if(BuildConfig.DEBUG){
+        if (BuildConfig.DEBUG) {
             Log.e(TAG, "dir: $dir")
         }
         launch {
             val changed = client.changeWorkingDirectory(dir)
-            if(changed){
+            manager[SharedPreferenceManager.FTPPATH] = client.printWorkingDirectory()
+            if (changed) {
                 getGWD()
                 callback.onDirChanged()
             }
         }
     }
 
     private suspend fun getGWD() {
-
+        if (BuildConfig.DEBUG) {
+            val cwm = client.printWorkingDirectory()
+            Log.e("CWD", "CWD: $cwm")
+        }
         val dir: Array<out FTPFile> = if (client.isConnected) {
-
-            if(BuildConfig.DEBUG) {
-                val cwm = client.printWorkingDirectory()
-                Log.e("CWD", "CWD: $cwm")
-            }
-
-            client.listFiles()
+            val listFiles = client.listFiles()
+            listFiles.sortByDescending { it.isDirectory }
+            listFiles
         } else arrayOf()
         withContext(Dispatchers.Main) {
             synchronized(_cwd) {
@@ -125,32 +166,45 @@ class MiFTPClientImpl @Inject constructor(@SharedPreferenceStorage override val
         }
     }
 
-    override fun up() {
-        launch {
-            client.cdup()
-            getGWD()
-        }
-    }
-
-    override suspend fun upload(file: String, byteArray: ByteArray): Boolean {
-        val stream = ByteArrayInputStream(byteArray)
-        return upload(file, stream)
-    }
 
     override suspend fun upload(file: String, stream: InputStream): Boolean {
-        client.enterLocalPassiveMode()
-        val file = client.storeFile(file, stream)
-        stream.close()
-        return file
+        if (client.isConnected) {
+            client.enterLocalPassiveMode()
+            val file = client.storeFile(file, stream)
+            stream.close()
+            if (file) {
+                getGWD()
+            }
+            return file
+        }
+        return false
     }
 
     override fun disconnect() {
         launch {
-            client.logout()
-            client.disconnect()
+            try {
+                client.removeProtocolCommandListener(this@MiFTPClientImpl)
+                client.logout()
+                client.disconnect()
+            } catch (e: Throwable) {
+                if (BuildConfig.DEBUG) {
+                    Log.e(TAG, e.message ?: "Something went wrong")
+                }
+            }
         }
     }
 
+    override suspend fun delete(file: FTPFile): Boolean {
+        if (client.isConnected) {
+            if (file.isFile) {
+                //TODO: WTF is this a bug?
+                val deleteFile = client.deleteFile("${ftpPath}/${file.name}")
+                getGWD()
+                return deleteFile
+            }
+        }
+        return false
+    }
 
     override fun protocolCommandSent(event: ProtocolCommandEvent?) {
         if (BuildConfig.DEBUG) {

app/src/main/java/nyc/vonley/mi/di/network/impl/SyncServiceImpl.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.*
 import nyc.vonley.mi.BuildConfig
 import nyc.vonley.mi.di.network.SyncService
 import nyc.vonley.mi.di.network.handlers.ClientHandler
+import nyc.vonley.mi.di.network.handlers.base.BaseClientHandler
 import nyc.vonley.mi.di.network.handlers.impl.ConsoleClientHandler
 import nyc.vonley.mi.di.network.listeners.OnConsoleListener
 import nyc.vonley.mi.extensions.client
@@ -166,11 +167,22 @@ class SyncServiceImpl constructor(
         this[ConsoleClientHandler::class.java].listeners[console.javaClass] = console
     }
 
+    override fun removeConsoleListener(console: OnConsoleListener) {
+        this[ConsoleClientHandler::class.java].listeners.remove(console.javaClass)
+    }
+
     /**
      * TODO: Clean up all listeners so there no
-     * memory leak1
+     * memory leak
      */
-    override fun cleanup() = Unit
+    override fun cleanup() {
+        this.handlers.onEach {
+            val handler = it.value
+            if (handler is BaseClientHandler<*, *>) {
+                handler.listeners.clear()
+            }
+        }
+    }
 
     /**
      * Fetch PS4 & PS3 Consoles on the current

app/src/main/java/nyc/vonley/mi/ui/main/ftp/FTPContract.kt

@@ -13,9 +13,9 @@ interface FTPContract {
     interface Presenter : BaseContract.Presenter, Observer<Array<out FTPFile>> {
         fun navigateTo(ftpFile: FTPFile)
         fun navigateTo(path: String)
-        fun delete(ftpFile: FTPFile): Boolean
-        fun download(ftpFile: FTPFile, location: String): Boolean
-        fun replace(ftpFile: FTPFile, file: File): Boolean
+        fun delete(ftpFile: FTPFile)
+        fun download(ftpFile: FTPFile, location: String)
+        fun replace(ftpFile: FTPFile, file: File)
         fun upload(filename: String, stream: InputStream)
         fun upload(filename: String, bytes: ByteArray) = upload(filename, ByteArrayInputStream(bytes))
         fun upload(file: File) = upload(file.name, FileInputStream(file))
@@ -29,6 +29,8 @@ interface FTPContract {
         fun onFTPLongClickFile(view: android.view.View, ftpFile: FTPFile)
         fun onFileUpload(filename: String)
         fun onFileFailed(filename: String)
+        fun onFTPFileDeleted(ftpFile: FTPFile)
+        fun onFTPFailedToDelete(ftpFile: FTPFile)
     }
 
 }

app/src/main/java/nyc/vonley/mi/ui/main/ftp/FTPFragment.kt

@@ -21,13 +21,15 @@ import androidx.core.database.getStringOrNull
 import androidx.fragment.app.Fragment
 import com.google.android.material.snackbar.Snackbar
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.android.synthetic.main.fragment_f_t_p.*
 import nyc.vonley.mi.BuildConfig
 import nyc.vonley.mi.R
 import nyc.vonley.mi.databinding.FragmentFTPBinding
 import nyc.vonley.mi.ui.main.ftp.adapters.FTPChildAttachChangeListener
 import nyc.vonley.mi.ui.main.ftp.adapters.FTPFileTouchListener
 import nyc.vonley.mi.ui.main.ftp.adapters.FTPRecyclerAdapter
 import nyc.vonley.mi.ui.main.ftp.adapters.FTPScrollListener
+import nyc.vonley.mi.ui.main.home.dialog
 import org.apache.commons.net.ftp.FTPFile
 import java.io.File
 import javax.inject.Inject
@@ -91,6 +93,7 @@ class FTPFragment : Fragment(), FTPContract.View, ActivityResultCallback<Activit
 
     override fun onFTPDirOpened(files: Array<out FTPFile>) {
         adapter.set(files)
+        recycler.scrollToPosition(0)
     }
 
     override fun onFTPDirClicked(ftpFile: FTPFile) {
@@ -109,14 +112,20 @@ class FTPFragment : Fragment(), FTPContract.View, ActivityResultCallback<Activit
         Toast.makeText(requireContext(), "Feature not implemented yet", Toast.LENGTH_SHORT).show()
     }
 
+
     override fun onFTPLongClickFile(view: View, ftpFile: FTPFile) {
         val popup = PopupMenu(view.context, view)
         val inflater = popup.menuInflater
         inflater.inflate(R.menu.ftp_long_click, popup.menu)
         popup.setOnMenuItemClickListener { item ->
             when (item.itemId) {
                 R.id.ftp_delete -> {
-                    presenter.delete(ftpFile)
+                    dialog("Are you sure you want to delete ${ftpFile.name}", "OK") { d, i ->
+                        presenter.delete(ftpFile)
+                        d.dismiss()
+                    }.setNegativeButton("Cancel") { d, i ->
+                        d.dismiss()
+                    }.create().show()
                     true
                 }
                 R.id.ftp_download -> {
@@ -145,11 +154,20 @@ class FTPFragment : Fragment(), FTPContract.View, ActivityResultCallback<Activit
     }
 
     override fun onFileUpload(filename: String) {
-        Snackbar.make(requireView(), "$filename upload successfully!", Snackbar.LENGTH_LONG).show()
+        Snackbar.make(requireView(), "$filename upload successful!", Snackbar.LENGTH_LONG).show()
     }
 
     override fun onFileFailed(filename: String) {
-        Snackbar.make(requireView(), "Failed to upload $filename", Snackbar.LENGTH_LONG).show()
+        Snackbar.make(requireView(), "Failed to upload $filename!", Snackbar.LENGTH_LONG).show()
+    }
+
+    override fun onFTPFileDeleted(ftpFile: FTPFile) {
+        Snackbar.make(requireView(), "${ftpFile.name} deleted!", Snackbar.LENGTH_LONG)
+            .show()
+    }
+
+    override fun onFTPFailedToDelete(ftpFile: FTPFile) {
+        Snackbar.make(requireView(), "Failed to delete $ftpFile!", Snackbar.LENGTH_LONG).show()
     }
 
     override fun onFTPFileClicked(ftpFile: FTPFile) {