Android - sgml/signature GitHub Wiki

// MainActivity.kt
package com.example.sshpushdemo

import android.net.Uri
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.jcraft.jsch.ChannelExec
import com.jcraft.jsch.JSch
import com.jcraft.jsch.Session
import java.io.BufferedReader
import java.io.InputStreamReader

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Set the layout for the activity.
        setContentView(R.layout.activity_main)

        // Default Git repository path used if no mailto event is detected.
        var gitRepoPath = "/remote/path/to/git/repo"

        // Check if the incoming intent contains a URI.
        intent.data?.let { uri ->
            // Check if the URI scheme is "mailto"
            if (uri.scheme.equals("mailto", ignoreCase = true)) {
                // **Important Limitation Note:**
                // The mailto protocol is designed to handle email addresses with optional parameters like subject and body.
                // Using it to pass a Git repository name is unconventional and has several limitations:
                //   - **Limited Structure:** A standard mailto URI is generally just an email address. It lacks the structure
                //     needed to specify file paths or repository details reliably.
                //   - **Encoding Issues:** Special characters and encoding in email addresses or extra parameters may be misinterpreted.
                //   - **Non-Standard Usage:** Relying on mailto in this way may lead to compatibility issues with components expecting standard mailto behavior.
                //   - **Ambiguity:** The scheme-specific part may contain additional unwanted query parameters (subject, cc, etc.),
                //     potentially complicating the extraction of a pure repo path.
                //
                // In this example, the scheme-specific part of the mailto URI is used as the repository name.
                gitRepoPath = uri.schemeSpecificPart
            }
        }

        // Log the chosen repository path for debugging purposes.
        println("Using Git repository path: $gitRepoPath")

        // Launch the SSH Git-push routine on a background thread.
        Thread {
            // Change these parameter values as needed.
            pushFileOverSSH(
                host = "your.remote.host",
                port = 22,
                username = "your_username",
                privateKeyPath = "/path/to/your/private_key",
                fileName = "target_file.txt",
                gitRepoPath = gitRepoPath
            )
        }.start()
    }
}

/**
 * Opens an SSH connection to a remote host, finds a given file within a Git repository,
 * and then executes Git commands ("git add", "git commit", and "git push") to push the file.
 *
 * @param host The remote SSH host.
 * @param port The SSH port (default is 22).
 * @param username The SSH username.
 * @param privateKeyPath The file system path to your SSH private key on Android.
 * @param fileName The name of the file to search for.
 * @param gitRepoPath The absolute path to the Git repository on the remote host,
 *                    or the repository name parsed from a "mailto:" URI.
 */
fun pushFileOverSSH(
    host: String,
    port: Int = 22,
    username: String,
    privateKeyPath: String,
    fileName: String,
    gitRepoPath: String
) {
    try {
        val jsch = JSch()
        // Add your SSH private key for authentication.
        jsch.addIdentity(privateKeyPath)

        // Open an SSH session with the provided host and credentials.
        val session: Session = jsch.getSession(username, host, port)
        // Disable strict host key checking for simplicity (not recommended for production).
        session.setConfig("StrictHostKeyChecking", "no")
        session.connect(30000) // Connection timeout set to 30 seconds

        // --- Step 1: Find the file in the repository ---
        // Use a 'find' command to search for the specified file at the root of the Git repository.
        val findCmd = "find $gitRepoPath -maxdepth 1 -type f -name '$fileName'"
        val findOutput = executeCommand(session, findCmd)
        println("Find command output: \n$findOutput")

        if (findOutput.isNotBlank()) {
            // --- Step 2: Execute Git commands to push the file ---
            // Navigate to the Git repository and perform git add, commit, and push operations.
            val gitCommands = """
                cd $gitRepoPath && 
                git add $fileName && 
                git commit -m 'Automated commit of $fileName' && 
                git push
            """.trimIndent()
            val gitOutput = executeCommand(session, gitCommands)
            println("Git commands output: \n$gitOutput")
        } else {
            println("File '$fileName' not found in repository path '$gitRepoPath'.")
        }

        // Disconnect the session once the commands have been executed.
        session.disconnect()
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

/**
 * Executes a command via an SSH exec channel and returns its output.
 *
 * @param session The connected SSH session.
 * @param command The command to execute.
 * @return The output of the command execution as a String.
 */
fun executeCommand(session: Session, command: String): String {
    val channel = session.openChannel("exec") as ChannelExec
    channel.setCommand(command)
    channel.inputStream = null
    val input = channel.inputStream
    channel.connect()

    // Read the output of the command.
    val reader = BufferedReader(InputStreamReader(input))
    val output = StringBuilder()
    reader.forEachLine { output.append(it).append("\n") }

    channel.disconnect()
    return output.toString().trim()
}

john_deere_hardware:
  - name: "John Deere G5 Display"
    description: "Advanced displays using an Android-based operating system to provide a user-friendly interface for managing various farming operations, including precision guidance, data collection, and machine control."
    url: "https://www.deere.com/en/technology-products/precision-ag-technology/g5-displays/"
  
  - name: "John Deere StarFire™ 7000/7500 Receivers"
    description: "Receivers using Android-based systems to provide high-accuracy GPS guidance and positioning for agricultural equipment."
    url: "https://www.deere.com/en/technology-products/precision-ag-technology/guidance/starfire-7000-7500-receivers/"
  
  - name: "John Deere CommandCenter™"
    description: "System integrated into John Deere tractors and combines, using an Android-based interface to manage machine settings, monitor performance, and control various functions."
    url: "https://www.deere.com/en/technology-products/precision-ag-technology/displays/commandcenter/"
  
  - name: "John Deere Gen 4 CommandCenter™"
    description: "Display system using an Android-based OS to provide a seamless user experience for managing machine operations, precision agriculture tasks, and data collection."
    url: "https://www.deere.com/en/technology-products/precision-ag-technology/displays/gen-4-commandcenter/"