ಬಟನ್ ಕ್ಲಿಕ್‌ನಲ್ಲಿ ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಮರೆಮಾಡಿ ಮತ್ತು ಹೊರಗೆ ಸ್ಪರ್ಶಿಸಿ

ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು

ಆಂಡ್ರಾಯ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಮಾನ್ಯವಾಗಿ ವರ್ಚುವಲ್ ಕೀಬೋರ್ಡ್ ಮೂಲಕ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅಗತ್ಯವಿರುತ್ತದೆ. ನಿಮ್ಮ ಲೇಔಟ್‌ನಲ್ಲಿ ನೀವು ಎಡಿಟ್‌ಟೆಕ್ಸ್ಟ್ ಮತ್ತು ಬಟನ್ ಹೊಂದಿರುವ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಕೀಬೋರ್ಡ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಪಠ್ಯವನ್ನು ನಮೂದಿಸಿದ ನಂತರ ಮತ್ತು ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದ ನಂತರ, ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸಲು ನೀವು ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು ಬಯಸಬಹುದು.

ಬಳಕೆದಾರರು ಕೀಬೋರ್ಡ್‌ನ ಹೊರಗಿನ ಪ್ರದೇಶಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಮುಚ್ಚುವುದು ಹೇಗೆ ಎಂಬುದಕ್ಕೆ ಈ ಲೇಖನವು ಸರಳ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ವಿವರಿಸಿದ ಹಂತಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ Android ಅಪ್ಲಿಕೇಶನ್‌ನ ಉಪಯುಕ್ತತೆ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನೀವು ಹೆಚ್ಚಿಸಬಹುದು.

ಅನುಷ್ಠಾನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು UI ನೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವಾಗ, ನಿರ್ದಿಷ್ಟವಾಗಿ ಪಠ್ಯವನ್ನು ನಮೂದಿಸಿದ ನಂತರ ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಗಿ ಮರೆಮಾಡಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. EditText ಕ್ಷೇತ್ರ ಮತ್ತು ಕ್ಲಿಕ್ a Button. ಜಾವಾ ಮತ್ತು ಕೋಟ್ಲಿನ್ ಉದಾಹರಣೆಗಳು ಹಲವಾರು ಪ್ರಮುಖ Android ಘಟಕಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ. ಅಗತ್ಯವಿರುವ ತರಗತಿಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಎರಡೂ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಪ್ರಾರಂಭವಾಗುತ್ತವೆ Activity, Context, InputMethodManager, ಮತ್ತು ವಿವಿಧ UI ಘಟಕಗಳು. ರಲ್ಲಿ onCreate ವಿಧಾನ, findViewById ಅನ್ನು ಲಿಂಕ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ EditText ಮತ್ತು Button ಲೇಔಟ್‌ನಿಂದ ಕೋಡ್‌ಗೆ. ದಿ setOnClickListener ನಂತರ ವಿಧಾನವನ್ನು ಪ್ರಚೋದಿಸಲು ಬಟನ್‌ನಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ hideKeyboard ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಕಾರ್ಯ.

ಎರಡೂ ಅನುಷ್ಠಾನಗಳಲ್ಲಿ, ದಿ hideKeyboard ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತದೆ getSystemService ಹಿಂಪಡೆಯಲು InputMethodManager ಸೇವೆ. ವಿಧಾನ hideSoftInputFromWindow ನಂತರ ಜೊತೆ ಕರೆಯಲಾಗುತ್ತದೆ getWindowToken ಅದರ EditText ಮೃದುವಾದ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ದಿ onTouchEvent ಬಳಕೆದಾರರು ಇನ್‌ಪುಟ್ ಕ್ಷೇತ್ರದ ಹೊರಗೆ ಸ್ಪರ್ಶಿಸಿದಾಗ ಕೀಬೋರ್ಡ್ ಮರೆಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿಧಾನವನ್ನು ಅತಿಕ್ರಮಿಸಲಾಗಿದೆ. ಈ ವಿಧಾನವು ಕೀಬೋರ್ಡ್ ವೀಕ್ಷಣೆಯನ್ನು ಅನಗತ್ಯವಾಗಿ ತಡೆಯುವ ಮೂಲಕ ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಈ ವಿಧಾನಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಮತ್ತು ಟಚ್ ಈವೆಂಟ್‌ಗಳನ್ನು ಸೂಕ್ತವಾಗಿ ನಿರ್ವಹಿಸುವ ಮೂಲಕ, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು Android ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಮೃದುವಾದ ಕೀಬೋರ್ಡ್ ನಡವಳಿಕೆಯನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ.

ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಇನ್‌ಪುಟ್ ಫೀಲ್ಡ್‌ನ ಹೊರಗೆ ಸ್ಪರ್ಶಿಸಿ

Android ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಜಾವಾವನ್ನು ಬಳಸುವುದು

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
 
public class MainActivity extends Activity {
    private EditText editText;
    private Button button;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        editText = findViewById(R.id.editText);
        button = findViewById(R.id.button);
 
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                hideKeyboard();
            }
        });
    }
 
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        hideKeyboard();
        return super.onTouchEvent(event);
    }
 
    private void hideKeyboard() {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    }
}

ಕೋಟ್ಲಿನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು Android ನಲ್ಲಿ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ವಜಾಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುವುದು

Android ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ Kotlin ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತಿದೆ

import android.app.Activity
import android.content.Context
import android.os.Bundle
import android.view.MotionEvent
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.Button
import android.widget.EditText
 
class MainActivity : Activity() {
    private lateinit var editText: EditText
    private lateinit var button: Button
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
        editText = findViewById(R.id.editText)
        button = findViewById(R.id.button)
 
        button.setOnClickListener { hideKeyboard() }
    }
 
    override fun onTouchEvent(event: MotionEvent): Boolean {
        hideKeyboard()
        return super.onTouchEvent(event)
    }
 
    private fun hideKeyboard() {
        val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(editText.windowToken, 0)
    }
}

ಕೀಬೋರ್ಡ್ ನಿರ್ವಹಣೆಗಾಗಿ ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಚುವ ಮೂಲ ವಿಧಾನಗಳನ್ನು ಮೀರಿ, ಡೆವಲಪರ್‌ಗಳು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಹೆಚ್ಚಿಸಲು ಹೆಚ್ಚು ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಬಹುದು. ಅಂತಹ ಒಂದು ವಿಧಾನವು ಬಳಕೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ TouchListeners ಸ್ಪರ್ಶ ಘಟನೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು ಬಹು UI ಘಟಕಗಳಲ್ಲಿ. ಬಳಕೆದಾರರು ಪರದೆಯ ಹೊರಗಿನ ಯಾವುದೇ ಭಾಗದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಿದಾಗ ಕೀಬೋರ್ಡ್ ಮರೆಮಾಡಲಾಗಿದೆ ಎಂದು ಈ ವಿಧಾನವು ಖಚಿತಪಡಿಸುತ್ತದೆ EditText. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಕೀಬೋರ್ಡ್ ಗೋಚರತೆಯನ್ನು ನಿರ್ವಹಿಸುವುದನ್ನು ಫೋಕಸಿಂಗ್ ಲಾಜಿಕ್‌ನೊಂದಿಗೆ ಜೋಡಿಸಬಹುದು, ಅಲ್ಲಿ ಫೋಕಸ್ ಅನ್ನು ದೂರಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ EditText ಮತ್ತೊಂದು ಘಟಕಕ್ಕೆ, ಕೀಬೋರ್ಡ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರೆಮಾಡಲು ಪ್ರೇರೇಪಿಸುತ್ತದೆ.

ಮತ್ತೊಂದು ತಂತ್ರವನ್ನು ಬಳಸುವುದು View.OnFocusChangeListener ಮೇಲೆ EditText. ಯಾವಾಗ ಎಂಬುದನ್ನು ಈ ಕೇಳುಗ ಪತ್ತೆ ಮಾಡಬಹುದು EditText ಗಮನವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ತರುವಾಯ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡುತ್ತದೆ. ಬಹು ಇನ್‌ಪುಟ್ ಕ್ಷೇತ್ರಗಳು ಒಳಗೊಂಡಿರುವ ಫಾರ್ಮ್‌ಗಳು ಅಥವಾ ಡೇಟಾ ಎಂಟ್ರಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಇದಲ್ಲದೆ, ಹೆಚ್ಚು ತಡೆರಹಿತ ಬಳಕೆದಾರ ಅನುಭವಕ್ಕಾಗಿ, ಡೆವಲಪರ್‌ಗಳು ಬಳಸಿಕೊಳ್ಳಬಹುದು SoftKeyboardStateWatcher, ಕೀಬೋರ್ಡ್‌ನ ಗೋಚರತೆಯ ಸ್ಥಿತಿಯ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಕಸ್ಟಮ್ ಅನುಷ್ಠಾನ ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ಅಂತಹ ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚು ಅರ್ಥಗರ್ಭಿತ ಮತ್ತು ಬಳಕೆದಾರ ಸ್ನೇಹಿ Android ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು.

ಆಂಡ್ರಾಯ್ಡ್ ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

1. ಕೀಬೋರ್ಡ್ ತೋರಿಸಿದಾಗ ಅಥವಾ ಮರೆಮಾಡಿದಾಗ ನಾನು ಹೇಗೆ ಕಂಡುಹಿಡಿಯಬಹುದು?
2. ನೀವು ಬಳಸಬಹುದು a SoftKeyboardStateWatcher ಕೀಬೋರ್ಡ್‌ನ ಗೋಚರತೆಯ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು.
3. ಬಳಕೆದಾರರು ಸ್ಕ್ರಾಲ್ ಮಾಡಿದಾಗ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರೆಮಾಡಲು ಸಾಧ್ಯವೇ?
4. ಹೌದು, ನೀವು ಎ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು OnScrollListener ಸ್ಕ್ರೋಲಿಂಗ್ ಸಮಯದಲ್ಲಿ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು ಸ್ಕ್ರಾಲ್ ವೀಕ್ಷಣೆಯಲ್ಲಿ.
5. ನಾನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಕೀಬೋರ್ಡ್ ಅನ್ನು ತೋರಿಸಬಹುದೇ a EditText ಕೇಂದ್ರೀಕೃತವಾಗಿದೆಯೇ?
6. ಹೌದು, ಬಳಸಿ InputMethodManager.showSoftInput ಯಾವಾಗ ಕೀಬೋರ್ಡ್ ತೋರಿಸಲು EditText ಗಮನವನ್ನು ಪಡೆಯುತ್ತದೆ.
7. ಬಳಕೆದಾರರು ಬ್ಯಾಕ್ ಬಟನ್ ಒತ್ತಿದಾಗ ನಾನು ಕೀಬೋರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಮರೆಮಾಡುವುದು?
8. ಅತಿಕ್ರಮಿಸಿ onBackPressed ವಿಧಾನ ಮತ್ತು ಬಳಸಿ ಕೀಬೋರ್ಡ್ ಮರೆಮಾಡಿ InputMethodManager.
9. ನಾನು ಕೀಬೋರ್ಡ್ ವಿನ್ಯಾಸವನ್ನು ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದೇ?
10. ಹೌದು, ಆಂಡ್ರಾಯ್ಡ್ ಮೂಲಕ ಕಸ್ಟಮ್ ಕೀಬೋರ್ಡ್ ಲೇಔಟ್‌ಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ InputMethodService.
11. ಕೀಬೋರ್ಡ್ ಅನ್ನು ತುಣುಕಿನಲ್ಲಿ ಮರೆಮಾಡಲು ಉತ್ತಮ ಮಾರ್ಗ ಯಾವುದು?
12. ಬಳಸಿ getActivity().getSystemService ಪಡೆಯಲು InputMethodManager ಒಂದು ತುಣುಕಿನಲ್ಲಿ.
13. ತುಣುಕುಗಳ ನಡುವೆ ಬದಲಾಯಿಸುವಾಗ ನಾನು ಕೀಬೋರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಮರೆಮಾಡಬಹುದು?
14. ಅಳವಡಿಕೆ FragmentTransaction ಸ್ವಿಚ್ ಸಮಯದಲ್ಲಿ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು ಕೇಳುಗನೊಂದಿಗೆ.
15. ಕೀಬೋರ್ಡ್‌ನ ಮರೆಮಾಚುವಿಕೆಯನ್ನು ಅನಿಮೇಟ್ ಮಾಡಲು ಸಾಧ್ಯವೇ?
16. ಹೌದು, ನೀವು ಹೊಂದಿರುವ ವೀಕ್ಷಣೆಯನ್ನು ಅನಿಮೇಟ್ ಮಾಡಬಹುದು EditText ಮೃದುವಾದ ಅಡಗಿಸುವ ಪರಿಣಾಮವನ್ನು ರಚಿಸಲು.

ಪ್ರಮುಖ ಟೇಕ್‌ಅವೇಗಳ ಸಾರಾಂಶ

ಅರ್ಥಗರ್ಭಿತ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು Android ಸಾಫ್ಟ್ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಕೀಬೋರ್ಡ್ ಅನ್ನು ಮರೆಮಾಡಲು InputMethodManager ಮತ್ತು hideSoftInputFromWindow ಅನ್ನು ಹಿಂಪಡೆಯಲು getSystemService ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಕೀಬೋರ್ಡ್ ಕಾಣಿಸಿಕೊಂಡಾಗ ಮತ್ತು ಕಣ್ಮರೆಯಾದಾಗ ನಿಯಂತ್ರಿಸಬಹುದು. ಟಚ್ ಮತ್ತು ಕ್ಲಿಕ್ ಕೇಳುಗರನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಈ ನಿಯಂತ್ರಣವನ್ನು ಇನ್ನಷ್ಟು ಪರಿಷ್ಕರಿಸುತ್ತದೆ, ಇತರ UI ಅಂಶಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವಾಗ ಕೀಬೋರ್ಡ್ ಸೂಕ್ತವಾಗಿ ಮರೆಮಾಡುತ್ತದೆ. ಪ್ರಮುಖ ವಿಷಯ ಅಥವಾ UI ಅಂಶಗಳನ್ನು ತಡೆಯುವುದರಿಂದ ಕೀಬೋರ್ಡ್ ತಡೆಯುವ ಮೂಲಕ ಈ ತಂತ್ರಗಳು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ.