android - एंड्रॉइड के लिए टर्मिनल एमुलेटर का निर्माण




terminal terminal-emulator (2)

मैं एंड्रॉइड के लिए टर्मिनल एमुलेटर बनाने की कोशिश कर रहा हूं। इस के लिए बहुत नया होने के नाते, मेरा विचार प्रत्येक कमांड को निष्पादित करना था और एक फ़ाइल में आउटपुट को संग्रहित करना था, जिनकी सामग्री प्रत्येक निष्पादन के बाद प्रदर्शित की जाएगी। छद्म कोड:

public Boolean execCommands(String command) {
        try {
            rt = Runtime.getRuntime();
            process = rt.exec("su");
            DataOutputStream os = new DataOutputStream(process.getOutputStream());
            os.writeBytes("echo $ \""+command+ "\" >> /sdcard/Android/data/terminalemulatorlog.txt\n\n\n"); 
            /**** Note :  String command = (EditText)findViewById(R.id.command).getText().toString(); ****/
            os.flush();
            os.writeBytes("exit\n");
            os.flush();
            process.waitFor();
            }
        // Error Handling
        displayOutput(); //Loads and displays the Text File (/sdcard/Android/data/terminalemulatorlog.txt)
        return true;
        }

कोड का यह टुकड़ा कुछ विशेष आदेशों (उदाहरण '' स्पष्ट ') को छोड़कर काम करता है। लेकिन मैं इसके बारे में अधिक चिंतित हूं कि निम्न समस्याएं हैं:

  1. हर बार एक कमांड निष्पादित किया जाता है, मैं सुपरयूसर अनुमति (कोड की दूसरी पंक्ति) की तलाश कर रहा हूं। और मैं इस से दूर करना चाहता हूं।
  2. ऐसे मामलों में जब उपयोगकर्ता एक कमांड को दूसरे में ले जाता है,
    जैसे कि :

    cd /sdcard    
    touch File.txt    

    File.txt '/' में बनाया गया है और '/ sdcard' में नहीं है अब से बचने के लिए, मैं वर्तमान 'सीडी' कमांडों का पता लगा रहा हूं ताकि वर्तमान कार्य निर्देशिका क्या है। और मुझे उम्मीद है कि इसके चारों ओर एक बेहतर तरीका है।

अगर कोई मेरी मदद कर सकता है तो मैं आभारी रहूंगा


यह थोड़ा देर हो चुकी है लेकिन यहां ऐसा करने के कुछ तरीके हैं।

1)

प्रारंभिक बिंदु उपयोग के रूप में सु उपयोग करने के बजाय / system / bin / sh

और कॉल करने के बाद

rt.exec("/system/bin/sh");

आपको आगे के आदेश देने के लिए आउटपुट स्ट्रीम और इनपुट स्ट्रीम पर पकड़ करनी चाहिए।

एक आदेश जारी करने के बाद आपको "--- EOF ---" जैसी एक जादू की रेखा गूंजनी चाहिए और उस पंक्ति को पढ़ने के बाद इनपुट को पढ़ना बंद करना चाहिए। यदि आपके पास यह नहीं है, तो आप इनटस्टस्ट्रीम अवरुद्ध से पढ़ने के कार्य के साथ समाप्त होंगे।

2) डेटा को आपके द्वारा लिखी गई मूल प्रक्रिया में पाइप करें, जो आपके एंड्रॉइड एप्लिकेशन पर डेटा को सीधे टर्मिनेटेड कैरेक्टर या स्ट्रिंग से जुड़ा होता है जो अंत से जुड़ा होता है।

मुझे पूरी तरह यकीन नहीं है कि यह कैसे करना है, लेकिन यह मूल रूप से उसी तरह की है, जैसा कि एक मध्यवर्ती व्यक्ति के रूप में आपके मूल अनुप्रयोग पर निर्भर करता है।

यह आपको कार्यशील "टर्मिनल एमुलेटर" के करीब ले जाएगा

3) यदि आप एक सच्चे टर्नामल इम्यूलेटर नहीं चाहते हैं तो इसके अलावा ऐसा करने का कोई अन्य तरीका नहीं है: एक मूल अनुप्रयोग का उपयोग करना जो एक psuedoterminal के लिए कनेक्शन खोलता है।

पीटीआई खोलने के बारे में यहां कुछ बुनियादी जानकारी दी गई है: लिंक

टर्मिनल एमुलेटर एक खुले स्रोत परियोजना है जो इस तकनीक का उपयोग करता है।

यहाँ एक नज़र डालें


सुनिश्चित नहीं है कि आपको अभी भी इसकी ज़रूरत है या नहीं, लेकिन यहां बताया गया है कि मैं एक समय में एक से अधिक आदेश जारी कर रहा हूं और "su" का इस्तेमाल नहीं कर रहा

try {
    String[] commands = {           
            "dumpstate > /sdcard/LogFiles/dumpstate.txt",
            "dumpsys > /sdcard/LogFiles/dumpsys.txt",
            "logcat -d > /sdcard/LogFiles/log.txt",
            "cat /sdcard/LogFiles/dumpstate.txt /sdcard/LogFiles/dumpsys.txt /sdcard/LogFiles/log.txt > /sdcard/LogFiles/bugreport.rtf" };
    Process p = Runtime.getRuntime().exec("/system/bin/sh -");
    DataOutputStream os = new DataOutputStream(p.getOutputStream());
    for (String tmpCmd : commands) {
        os.writeBytes(tmpCmd + "\n");
    }
} catch (IOException e) {
    e.printStackTrace();
}




terminal-emulator