সফট কীবোর্ড অ্যান্ড্রয়েডের একটি ক্রিয়াকলাপে খোলা এবং ঘনিষ্ঠ শ্রোতা

Question

আমার Activityযেখানে আছে সেখানে 5 জন রয়েছে EditText। ব্যবহারকারীর প্রথমটিতে ক্লিক EditTextকরলে নরম কীবোর্ড এতে কিছু মান প্রবেশ করানোর জন্য খোলে। নরম কীবোর্ডটি যখন খোলা হয় এবং যখন ব্যবহারকারী প্রথমটিতে ক্লিক করে এবং যখন নরম কীবোর্ডটি ব্যাক বোতাম টিপলে একই থেকে বন্ধ হয় তখন আমি অন্য Viewকিছুটির দৃশ্যমানতা সেট করতে চাই । তারপরে আমি অন্য কিছুটির দৃশ্যমানতার জন্য সেট করতে চাই ।GoneEditTextEditTextView

EditTextঅ্যান্ড্রয়েডের প্রথমটিতে ক্লিক করে সফট কীবোর্ডটি যখন খুলবে তখন কি কোনও শ্রোতা বা কলব্যাক বা কোনও হ্যাক রয়েছে ?

Comments

না। এমন শ্রোতা নেই। সেখানে হয় অর্জন করা কি করার চেষ্টা করছেন হ্যাক। এখানে একটি সম্ভাব্য পন্থা: অ্যান্ড্রয়েডে পয়েন্টার ইভেন্টটি কীভাবে প্রেরণ করা যায় ।

— বিক্রম

@ ভিক্রাম আমি খুঁজছি নাtrying to detect the virtual keyboard height in Android.

— এন শর্মা

আমি জানি. আপনি যদি কোডটি দিয়ে যান তবে আপনি দেখতে পাবেন যে উচ্চতা কীভাবে নির্ধারণ করা হচ্ছে। একটি পয়েন্টার ইভেন্ট প্রেরণ করা হচ্ছে -> দুটি কেস => ১. কীবোর্ডটি ওপেন থাকলে => & যদি পয়েন্টারের অবস্থান Xএবং Yঅবস্থানটি কীবোর্ডের উপরে /> SecurityException=> হ্রাস হ্রাস পায় Yএবং কোনও ব্যতিক্রম ছোঁড়া না হওয়া অবধি আবার চেষ্টা করুন => বর্তমান Yমান হ'ল কীবোর্ডের উচ্চতা। ২. কীবোর্ডটি খোলা না থাকলে => নং SecurityException।

— বিক্রম

এটি আপনার দৃশ্যে কীভাবে প্রযোজ্য? স্ক্রিনের উচ্চতার 2/3 বলুন একটি পয়েন্টার ইভেন্ট পাঠান। যদি একটি SecurityExceptionনিক্ষিপ্ত হয় => কীবোর্ড খোলা থাকে। অন্যথায়, কীবোর্ড বন্ধ আছে।

— বিক্রম

@ বিক্রম আমি কেবল এটির জন্য প্রথম চাই EditTextঅন্যটি নয় EditText। আমি কিভাবে এই পার্থক্য করতে পারি?

— এন শর্মা

Answer 1

এটি কেবল তখনই কাজ করে যখন android:windowSoftInputModeআপনার ক্রিয়াকলাপ adjustResizeম্যানিফেস্টে সেট করা থাকে। আপনার কার্যকলাপের মূল বিন্যাসটি কীবোর্ডের মাধ্যমে পুনরায় আকার দেওয়া হয়েছে কিনা তা দেখতে আপনি একটি বিন্যাস শ্রোতাদের ব্যবহার করতে পারেন।

আমি আমার ক্রিয়াকলাপের জন্য নিম্নলিখিত বেস ক্লাসের মতো কিছু ব্যবহার করি:

public class BaseActivity extends Activity {
    private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            int heightDiff = rootLayout.getRootView().getHeight() - rootLayout.getHeight();
            int contentViewTop = getWindow().findViewById(Window.ID_ANDROID_CONTENT).getTop();

            LocalBroadcastManager broadcastManager = LocalBroadcastManager.getInstance(BaseActivity.this);

            if(heightDiff <= contentViewTop){
                onHideKeyboard();

                Intent intent = new Intent("KeyboardWillHide");
                broadcastManager.sendBroadcast(intent);
            } else {
                int keyboardHeight = heightDiff - contentViewTop;
                onShowKeyboard(keyboardHeight);

                Intent intent = new Intent("KeyboardWillShow");
                intent.putExtra("KeyboardHeight", keyboardHeight);
                broadcastManager.sendBroadcast(intent);
            }
        }
    };

    private boolean keyboardListenersAttached = false;
    private ViewGroup rootLayout;

    protected void onShowKeyboard(int keyboardHeight) {}
    protected void onHideKeyboard() {}

    protected void attachKeyboardListeners() {
        if (keyboardListenersAttached) {
            return;
        }

        rootLayout = (ViewGroup) findViewById(R.id.rootLayout);
        rootLayout.getViewTreeObserver().addOnGlobalLayoutListener(keyboardLayoutListener);

        keyboardListenersAttached = true;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (keyboardListenersAttached) {
            rootLayout.getViewTreeObserver().removeGlobalOnLayoutListener(keyboardLayoutListener);
        }
    }
}

নিম্নলিখিত উদাহরণের ক্রিয়াকলাপটি কীবোর্ড প্রদর্শিত হবে এবং একটি দৃশ্য লুকানোর জন্য এটি ব্যবহার করে এবং কীবোর্ডটি যখন লুকানো থাকে তখন আবার দেখায়।

এক্সএমএল লেআউট:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:id="@+id/rootLayout"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">              

    <ScrollView
        android:id="@+id/scrollView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        >

        <!-- omitted for brevity -->

    </ScrollView>

    <LinearLayout android:id="@+id/bottomContainer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        >

        <!-- omitted for brevity -->

    </LinearLayout>

</LinearLayout>

এবং ক্রিয়াকলাপ:

public class TestActivity extends BaseActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.test_activity);

        attachKeyboardListeners();
    }

    @Override
    protected void onShowKeyboard(int keyboardHeight) {
        // do things when keyboard is shown
        bottomContainer.setVisibility(View.GONE);
    }

    @Override
    protected void onHideKeyboard() {
        // do things when keyboard is hidden
        bottomContainer.setVisibility(View.VISIBLE);
    }        
}

Comments

+1 হ্যাঁ এটিই আমার সমস্যার সঠিক সমাধান।

— এন শর্মা

হাই, আপনি উইন্ডোতে getTop () ব্যবহার করেছেন ID ID_ANDROID_CONTENT। শীর্ষস্থানীয় হওয়া আমার পক্ষে কাজ করে না। এটি এখানে সর্বদা 0 থাকে, এটি পরিবর্তে getHeight () ব্যবহার করার কথা বলে মনে হয়।

— ড্যানিয়েলে সেগাটো

আপনি কোথা rootLayout = (ViewGroup) findViewById(R.id.rootLayout);থেকে পাবেন?

— কমনসেন্সকোড

কোনও কারণে আমার জন্য কাজ করা হচ্ছে না, এটি সর্বদা শো কীবোর্ডে কল করে হয় আমি এটি খুলি বা বন্ধ করে দিই। আমি FindViewById (android.R.id.content) ব্যবহার করছি, সম্ভবত এটাই সমস্যা?

— ম্যাকসুলিভান ডি'অ্যান্ডার

@tsig আপনার +100 সমাধান নির্দিষ্ট স্ক্রিনের উপর নির্ভর করে। ট্যাবলেট এবং এইচডিপিআই ফোনে ব্যর্থ। আমি ডিভাইসের উচ্চতার দশ শতাংশ হিসাবে সংশোধন ব্যবহার করেছি। এর অর্থ যদি স্ক্রিন হাইটের চেয়ে দেখার উচ্চতা কম হয় - 10% কীবোর্ডটি খোলা থাকে। অন্যথায় কীবোর্ড বন্ধ আছে। ContentViewTop = (getWindow () getDecorView () getBottom () / 10।।): এখানে onGlobalLayout আমার contentViewTop হয়

— ilker

Answer 2

দুর্দান্ত কীবোর্ডভিজিবিলিটিভেন্ট লাইব্রেরি সহ কেকের টুকরো

KeyboardVisibilityEvent.setEventListener(
    getActivity(),
    new KeyboardVisibilityEventListener() {
        @Override
        public void onVisibilityChanged(boolean isOpen) {
            // write your code
        }
    });

ইয়াসুহিরো শিমিজু-র ক্রেডিট

Comments

এটি কাজ করবে না কারণ কীবোর্ডগুলির স্থির উচ্চতা নেই এবং এই লাইব্রেরির উচ্চতা 100 ডিপিতে সেট করা হয়েছে।

— milosmns

@ মিলস্মনস কীবোর্ড সনাক্তকরণের জন্য 100 ডিপি একটি প্রান্তিক উচ্চতা ব্যবহৃত হয়। আসল কীবোর্ড উচ্চতা সম্পর্কে কোনও অনুমান করা হয় না

— নিনো ভ্যান হুফ

এটি এখনও হার্ড কোডেড। একাধিক জানালা? স্যামসুং স্প্লিট ভিউ? ছবি মোডে ছবি? এছাড়াও একটি সর্বনিম্ন এক-সারি কীবোর্ড রয়েছে যা বেলো 100 ডিপি পড়বে। এখানে কোনও রূপোর বুলেট নেই ...

— মিলোস্মেন্স

যেহেতু এই ইস্যুটির জন্য কোনও ধরা নেই, তাই এটি বাস্তবায়ন করা সবচেয়ে সহজ বলে মনে হচ্ছে এবং আপনি যে

— মেশিন ট্রাইব

এটি এখন পর্যন্ত সর্বোত্তম উত্তর, কোনও ডিভাইসে সম্পূর্ণ নির্ভরযোগ্য

— পেলেনেস

Answer 3

বিক্রম মন্তব্যগুলিতে যেমন উল্লেখ করেছেন, সফটকিবোর্ডটি প্রদর্শিত হয়েছে বা অদৃশ্য হয়েছে তা সনাক্ত করা কেবল কিছু কুৎসিত হ্যাকের সাহায্যেই সম্ভব।

হয়তো এটা করা যথেষ্ট editText উপর নজরদারি শ্রোতা সেট :

yourEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            //got focus
        } else {
            //lost focus
        }
   }
});

Comments

ধরা যাক আমি এডিটেক্সট এ ক্লিক করেছি তারপরে setOnFocusChangeListenerশ্রোতা বলা হবে তারপরে আমি টিপুন আবার কীবোর্ডটি বন্ধ করে দেয় এবং অন্যান্য ভিউগুলিতে ক্লিক করেনি, এখন আবার আমি একই সম্পাদনাটিতে ক্লিক করেছি যা ইতিমধ্যে ফোকাস করেছে তবে কি হবে?

— এন শর্মা

@ উইলিয়ামস আমি পুরোপুরি নিশ্চিত নই, তবে আমি সন্দেহ করি যে onFocusChange()ডাকা হবে না।

— কমনগ্যু

এটা আমার প্রশ্ন নয়। দয়া করে আমার প্রশ্নটি আবার পড়ুন - আমার ক্রিয়াকলাপ যেখানে 5 টি সম্পাদনা পাঠ রয়েছে। ব্যবহারকারীরা যখন প্রথম সম্পাদনা পাঠ্য ক্লিক করুন তখন নরম কীবোর্ড এতে কিছু মান প্রবেশ করুন। আমি প্রথমে এডিটেক্সট ক্লিক করে যখন ব্যবহারকারীরা প্রথম এডিটেক্সট ক্লিক করে নরম কীবোর্ড খোলার পরে অন্য কিছু দৃশ্যের দৃশ্যমানতা সেট করতে চাই এবং যখন একই সম্পাদনা পাঠ্যর কাছে সফ্ট কীবোর্ডটি বন্ধ হয়ে যায় তখন আমি অন্য কিছু দৃশ্যের দৃশ্যমানতার দৃশ্যমানকে সেট করতে চাই। অ্যান্ড্রয়েডের প্রথম এডিটেক্সট-এ ক্লিক করে নরম কীবোর্ড খুললে কি শ্রোতা বা কলব্যাক বা কোনও হ্যাক রয়েছে?

— এন শর্মা

ছেলেরা এই উত্তরটি দেখছে না কারণ সে অন্য কিছু বলছে এমনকি আমি বুঝতে পারি না।

— এন শর্মা

যাইহোক, এটি আমার পক্ষে কার্যকর হয় না ... যখন নরম কীবোর্ডটি লুকানো থাকে, সম্পাদনা পাঠ্যে কোনও ফোকাস পরিবর্তন হয় নি ... তাই আমি এই শ্রোতার কাছ থেকে বিজ্ঞপ্তি পেতে পারি না।

— লিক্যাট জুলিয়াস

Answer 4

ক্রিয়াকলাপের জন্য:

    final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                Rect r = new Rect();

                activityRootView.getWindowVisibleDisplayFrame(r);

                int heightDiff = view.getRootView().getHeight() - (r.bottom - r.top);
                if (heightDiff > 100) { 
                 //enter your code here
                }else{
                 //enter code for hid
                }
            }
        });

খণ্ডের জন্য:

    view = inflater.inflate(R.layout.live_chat_fragment, null);
view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                Rect r = new Rect();
                //r will be populated with the coordinates of your view that area still visible.
                view.getWindowVisibleDisplayFrame(r);

                int heightDiff = view.getRootView().getHeight() - (r.bottom - r.top);
                if (heightDiff > 500) { // if more than 100 pixels, its probably a keyboard...

                }
            }
        });

Comments

এটিকে ক্রিয়াকলাপের জন্য ব্যবহার করা হয়েছে, তবে স্ক্রিনের আকারের সাথে তুলনা করার পরিবর্তে আমি দেখতে চাই দুর্দান্ত কাজ করে

— রুই

উচ্চতার চেয়ে উচ্চতর ডিফের তুলনায় ডিপিতে বরং পিক্সেলগুলির সাথে তুলনা করা ভাল। এটি উল্লেখযোগ্যভাবে পরিবর্তিত হতে পারে।

— লিও ড্রয়েডকোডার

এটি কি android:windowSoftInputMode="adjustResize"ম্যানিফেস্টের প্রয়োজন ?

— লিউয়েনবিন_না

অ্যান্ড্রয়েড: উইন্ডোসফটআইনপুটমোড = "অ্যাডজাস্টেরেসাইজ করুন" অ্যান্ড্রয়েড: কনফিগারেশন = "ওরিয়েন্টেশন | কীবোর্ড | কীবোর্ডহাইডেড"

— এম সিং করনাওয়াত

এটি আমার পক্ষে কাজ করে, এখনও, আমার একটি প্রশ্ন আছে have এটি কি অনেকগুলি রিসোস খরচ?

— লিক্যাট জুলিয়াস

Answer 5

Jaap এর উত্তর AppCompatActivity জন্য কাজ করবে না। পরিবর্তে স্থিতি দণ্ড এবং নেভিগেশন বার ইত্যাদির উচ্চতা পান এবং আপনার অ্যাপ্লিকেশনটির উইন্ডো আকারের সাথে তুলনা করুন।

তাই ভালো:

    private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        // navigation bar height
        int navigationBarHeight = 0;
        int resourceId = getResources().getIdentifier("navigation_bar_height", "dimen", "android");
        if (resourceId > 0) {
            navigationBarHeight = getResources().getDimensionPixelSize(resourceId);
        }

        // status bar height
        int statusBarHeight = 0;
        resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0) {
            statusBarHeight = getResources().getDimensionPixelSize(resourceId);
        }

        // display window size for the app layout
        Rect rect = new Rect();
        getWindow().getDecorView().getWindowVisibleDisplayFrame(rect);

        // screen height - (user app height + status + nav) ..... if non-zero, then there is a soft keyboard
        int keyboardHeight = rootLayout.getRootView().getHeight() - (statusBarHeight + navigationBarHeight + rect.height());

        if (keyboardHeight <= 0) {
            onHideKeyboard();
        } else {
            onShowKeyboard(keyboardHeight);
        }
    }
};

Comments

এক ব্যতিক্রমের সাথে বেশ ভালভাবে কাজ করছে বলে মনে হচ্ছে: স্প্লিট স্ক্রিন মোডে ব্রেক। অন্যথায় এটি দুর্দান্ত।

— এমসিএলএলসি

Answer 6

আপনি চেষ্টা করতে পারেন:

private void initKeyBoardListener() {
    // Минимальное значение клавиатуры. 
    // Threshold for minimal keyboard height.
    final int MIN_KEYBOARD_HEIGHT_PX = 150;
    // Окно верхнего уровня view. 
    // Top-level window decor view.
    final View decorView = getWindow().getDecorView();
    // Регистрируем глобальный слушатель. Register global layout listener.
    decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        // Видимый прямоугольник внутри окна. 
        // Retrieve visible rectangle inside window.
        private final Rect windowVisibleDisplayFrame = new Rect();
        private int lastVisibleDecorViewHeight;

        @Override
        public void onGlobalLayout() {
            decorView.getWindowVisibleDisplayFrame(windowVisibleDisplayFrame);
            final int visibleDecorViewHeight = windowVisibleDisplayFrame.height();

            if (lastVisibleDecorViewHeight != 0) {
                if (lastVisibleDecorViewHeight > visibleDecorViewHeight + MIN_KEYBOARD_HEIGHT_PX) {
                    Log.d("Pasha", "SHOW");
                } else if (lastVisibleDecorViewHeight + MIN_KEYBOARD_HEIGHT_PX < visibleDecorViewHeight) {
                    Log.d("Pasha", "HIDE");
                }
            }
            // Сохраняем текущую высоту view до следующего вызова.
            // Save current decor view height for the next call.
            lastVisibleDecorViewHeight = visibleDecorViewHeight;
        }
    });
}

Comments

স্প্যাসিবো, ডলবিক! :)

— অ্যালেক্স

Answer 7

আপনি আমার আরএক্স এক্সটেনশন ফাংশন (কোটলিন) ব্যবহার করতে পারেন।

/**
 * @return [Observable] to subscribe of keyboard visibility changes.
 */
fun AppCompatActivity.keyboardVisibilityChanges(): Observable<Boolean> {

    // flag indicates whether keyboard is open
    var isKeyboardOpen = false

    val notifier: BehaviorSubject<Boolean> = BehaviorSubject.create()

    // approximate keyboard height
    val approximateKeyboardHeight = dip(100)

    // device screen height
    val screenHeight: Int = getScreenHeight()

    val visibleDisplayFrame = Rect()

    val viewTreeObserver = window.decorView.viewTreeObserver

    val onDrawListener = ViewTreeObserver.OnDrawListener {

        window.decorView.getWindowVisibleDisplayFrame(visibleDisplayFrame)

        val keyboardHeight = screenHeight - (visibleDisplayFrame.bottom - visibleDisplayFrame.top)

        val keyboardOpen = keyboardHeight >= approximateKeyboardHeight

        val hasChanged = isKeyboardOpen xor keyboardOpen

        if (hasChanged) {
            isKeyboardOpen = keyboardOpen
            notifier.onNext(keyboardOpen)
        }
    }

    val lifeCycleObserver = object : GenericLifecycleObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event?) {
            if (source.lifecycle.currentState == Lifecycle.State.DESTROYED) {
                viewTreeObserver.removeOnDrawListener(onDrawListener)
                source.lifecycle.removeObserver(this)
                notifier.onComplete()
            }
        }
    }

    viewTreeObserver.addOnDrawListener(onDrawListener)
    lifecycle.addObserver(lifeCycleObserver)

    return notifier
            .doOnDispose {
                viewTreeObserver.removeOnDrawListener(onDrawListener)
                lifecycle.removeObserver(lifeCycleObserver)
            }
            .onTerminateDetach()
            .hide()
}

উদাহরণ:

(context as AppCompatActivity)
                    .keyboardVisibilityChanges()
                    .subscribeBy { isKeyboardOpen ->
                        // your logic
                    }

Comments

আমার জন্য কাজ করে না। পদ্ধতিগুলি খুঁজে dip()getScreenHeight()

— পাচ্ছে

@ মার্সিনকুনার্ট এটি কেবলমাত্র এক্সটেনশন ফাংশন যা আপনাকে পিক্সেলকে ডিপিতে রূপান্তর করতে এবং স্ক্রিনের উচ্চতা পেতে সহায়তা করে। আপনি যদি চান তবে আমি আপনাকে এই জাতীয় ফাংশনগুলির উদাহরণ দিতে পারি

— ভ্লাদ

জেনেরিক্লাইফাইসাইকেলঅবার্সার অবচিত করা হয়? কোন সমাধান?

— জয়নাল ফাহরুদ্দিন

Answer 8

নীচের কোডটি আমার পক্ষে কাজ করছে,

mainLayout.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        @Override
        public void onGlobalLayout() {
            if (mainLayout != null) {
                int heightDiff = mainLayout.getRootView().getHeight() - mainLayout.getHeight();
                if (heightDiff > dpToPx(getActivity(), 200)) { 
                   //keyboard is open
                } else {
                   //keyboard is hide
                }
            }
        }
    });

Answer 9

যদি আপনি পারেন তবে এডিট টেক্সট প্রসারিত করার চেষ্টা করুন এবং 'onKeyPreIme' পদ্ধতিটি ওভাররাইড করুন।

@Override
public void setOnEditorActionListener(final OnEditorActionListener listener) {
    mEditorListener = listener; //keep it for later usage
    super.setOnEditorActionListener(listener);
}

@Override
public boolean onKeyPreIme(final int keyCode, final KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP) {
        if (mEditorListener != null) {
            //you can define and use custom listener,
            //OR define custom R.id.<imeId>
            //OR check event.keyCode in listener impl
            //* I used editor action because of ButterKnife @
            mEditorListener.onEditorAction(this, android.R.id.closeButton, event);
        }
    }
    return super.onKeyPreIme(keyCode, event);
}

আপনি কীভাবে এটি প্রসারিত করতে পারেন:

1. ফোকাস শোনার বাস্তবায়ন করুন এবং 'অনকায়ারবোর্ডশাউন' ঘোষণা করুন
2. 'কি-বোর্ড হিডেন' ঘোষণা করুন

আমি মনে করি, স্ক্রিনের উচ্চতার পুনঃ গণনাটি আগের মতো সফলভাবে 100% নয় successfully স্পষ্টতই, 'onKeyPreIme' ওভাররাইডিংকে 'প্রোগ্রাম সফটওয়্যারটি সফ্ট কীবোর্ড হাইড করুন' পদ্ধতিতে বলা হয় না, তবে আপনি যদি এটি কোথাও করছেন তবে আপনার 'onKeyboardHided' যুক্তিটি করা উচিত এবং একটি বিস্তৃত সমাধান তৈরি করা উচিত নয়।

Answer 10

public class MainActivity extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.mainactivity);
    attachKeyboardListeners();
    ....
    yourEditText1.setOnFocusChangeListener(new OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
            if (hasFocus) {
                yourEditText2.setVisibility(View.GONE);
                yourEditText3.setVisibility(View.GONE);
                yourEditText4.setVisibility(View.GONE);
                yourEditText5.setVisibility(View.GONE);
            } else {
                yourEditText2.setVisibility(View.VISIBLE);
                yourEditText3.setVisibility(View.VISIBLE);
                yourEditText4.setVisibility(View.VISIBLE);
                yourEditText5.setVisibility(VISIBLE);
            }
       }
    });
    }
}

Comments

ধরা যাক আমি এডিটেক্সট এ ক্লিক করেছি তারপরে setOnFocusChangeListenerশ্রোতা বলা হবে তারপরে আমি টিপুন আবার কীবোর্ডটি বন্ধ করে দেয় এবং অন্যান্য ভিউগুলিতে ক্লিক করেনি, এখন আবার আমি একই সম্পাদনাটিতে ক্লিক করেছি যা ইতিমধ্যে ফোকাস করেছে তবে কি হবে?

— এন শর্মা

এটা আমার প্রশ্ন নয়। দয়া করে আমার প্রশ্নটি আবার পড়ুন - আমার ক্রিয়াকলাপ যেখানে 5 টি সম্পাদনা পাঠ রয়েছে। ব্যবহারকারীরা যখন প্রথম সম্পাদনা পাঠ্য ক্লিক করুন তখন নরম কীবোর্ড এতে কিছু মান প্রবেশ করুন। আমি প্রথমে এডিটেক্সট ক্লিক করে যখন ব্যবহারকারীরা প্রথম এডিটেক্সট ক্লিক করে নরম কীবোর্ড খোলার পরে অন্য কিছু দৃশ্যের দৃশ্যমানতা সেট করতে চাই এবং যখন একই সম্পাদনা পাঠ্যর কাছে সফ্ট কীবোর্ডটি বন্ধ হয়ে যায় তখন আমি অন্য কিছু দৃশ্যের দৃশ্যমানতার দৃশ্যমানকে সেট করতে চাই। অ্যান্ড্রয়েডের প্রথম এডিটেক্সট-এ ক্লিক করে নরম কীবোর্ড খুললে কি শ্রোতা বা কলব্যাক বা কোনও হ্যাক রয়েছে?

— এন শর্মা

আপনি যখন পিছনে টিপুন তখন এটি কীবোর্ডটি খারিজ করে দেয় যে onfocusশ্রোতা কখনই তাকে ডাকে না যে আমি আপনাকে প্রস্তাব দিচ্ছি না

— এন শর্মা

Answer 11

এই ক্লাসটি ব্যবহার করুন,

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class SoftKeyboard implements View.OnFocusChangeListener
{
private static final int CLEAR_FOCUS = 0;

private ViewGroup layout;
private int layoutBottom;
private InputMethodManager im;
private int[] coords;
private boolean isKeyboardShow;
private SoftKeyboardChangesThread softKeyboardThread;
private List<EditText> editTextList;

private View tempView; // reference to a focused EditText

public SoftKeyboard(ViewGroup layout, InputMethodManager im)
{
    this.layout = layout;
    keyboardHideByDefault();
    initEditTexts(layout);
    this.im = im;
    this.coords = new int[2];
    this.isKeyboardShow = false;
    this.softKeyboardThread = new SoftKeyboardChangesThread();
    this.softKeyboardThread.start();
}

public void openSoftKeyboard()
{
    if(!isKeyboardShow)
    {
        layoutBottom = getLayoutCoordinates();
        im.toggleSoftInput(0, InputMethodManager.SHOW_IMPLICIT);
        softKeyboardThread.keyboardOpened();
        isKeyboardShow = true;
    }
}

public void closeSoftKeyboard()
{
    if(isKeyboardShow)
    {
        im.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
        isKeyboardShow = false;
    }
}

public void setSoftKeyboardCallback(SoftKeyboardChanged mCallback)
{
    softKeyboardThread.setCallback(mCallback);
}

public void unRegisterSoftKeyboardCallback()
{
    softKeyboardThread.stopThread();
}

public interface SoftKeyboardChanged 
{
    public void onSoftKeyboardHide();
    public void onSoftKeyboardShow();   
}

private int getLayoutCoordinates()
{
    layout.getLocationOnScreen(coords);
    return coords[1] + layout.getHeight();
}

private void keyboardHideByDefault()
{
    layout.setFocusable(true);
    layout.setFocusableInTouchMode(true);
}

/*
 * InitEditTexts now handles EditTexts in nested views
 * Thanks to Francesco Verheye ([e-mail])
 */
private void initEditTexts(ViewGroup viewgroup) 
{
    if(editTextList == null)
        editTextList = new ArrayList<EditText>();

    int childCount = viewgroup.getChildCount();
    for(int i=0; i<= childCount-1;i++) 
    {
        View v = viewgroup.getChildAt(i);

        if(v instanceof ViewGroup) 
        {
            initEditTexts((ViewGroup) v);
        }

        if(v instanceof EditText) 
        {
            EditText editText = (EditText) v;
            editText.setOnFocusChangeListener(this);
            editText.setCursorVisible(true);
            editTextList.add(editText);
        }
    }
}

/*
 * OnFocusChange does update tempView correctly now when keyboard is still shown
 * Thanks to Israel Dominguez ([e-mail])
 */
@Override
public void onFocusChange(View v, boolean hasFocus) 
{
    if(hasFocus) 
    {
        tempView = v;
        if(!isKeyboardShow) 
        {
            layoutBottom = getLayoutCoordinates();
            softKeyboardThread.keyboardOpened();
            isKeyboardShow = true;
        }
    }
}

// This handler will clear focus of selected EditText
private final Handler mHandler = new Handler()
{
    @Override
    public void handleMessage(Message m)
    {
        switch(m.what)
        {
        case CLEAR_FOCUS:
            if(tempView != null)
            {
                tempView.clearFocus();
                tempView = null;
            }
            break;
        }
    }
};

private class SoftKeyboardChangesThread extends Thread
{
    private AtomicBoolean started;
    private SoftKeyboardChanged mCallback;

    public SoftKeyboardChangesThread()
    {
        started = new AtomicBoolean(true);
    }

    public void setCallback(SoftKeyboardChanged mCallback)
    {
        this.mCallback = mCallback;
    }

    @Override
    public void run()
    {
        while(started.get())
        {
            // Wait until keyboard is requested to open
            synchronized(this)
            {
                try 
                {
                    wait();
                } catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }
            }

            int currentBottomLocation = getLayoutCoordinates();

            // There is some lag between open soft-keyboard function and when it really appears.
            while(currentBottomLocation == layoutBottom && started.get())
            {
                currentBottomLocation = getLayoutCoordinates();
            }

            if(started.get())
                mCallback.onSoftKeyboardShow();

            // When keyboard is opened from EditText, initial bottom location is greater than layoutBottom
            // and at some moment equals layoutBottom.
            // That broke the previous logic, so I added this new loop to handle this.
            while(currentBottomLocation >= layoutBottom && started.get())
            {
                currentBottomLocation = getLayoutCoordinates();
            }

            // Now Keyboard is shown, keep checking layout dimensions until keyboard is gone
            while(currentBottomLocation != layoutBottom && started.get())
            {
                                    synchronized(this)
                {
                    try 
                    {
                        wait(500);
                    } catch (InterruptedException e) 
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                currentBottomLocation = getLayoutCoordinates();
            }

            if(started.get())
                mCallback.onSoftKeyboardHide();

            // if keyboard has been opened clicking and EditText.
            if(isKeyboardShow && started.get())
                isKeyboardShow = false;

            // if an EditText is focused, remove its focus (on UI thread)
            if(started.get())
                mHandler.obtainMessage(CLEAR_FOCUS).sendToTarget();
        }   
    }

    public void keyboardOpened()
    {
        synchronized(this)
        {
            notify();
        }
    }

    public void stopThread()
    {
        synchronized(this)
        {
            started.set(false);
            notify();
        }
    }

}
}

ইন Android Manifest, android:windowSoftInputMode="adjustResize"প্রয়োজনীয়।

/*
Somewhere else in your code
*/
RelativeLayout mainLayout = findViewById(R.layout.main_layout); // You must use the layout root
InputMethodManager im = (InputMethodManager)getSystemService(Service.INPUT_METHOD_SERVICE);

/*
Instantiate and pass a callback
*/
SoftKeyboard softKeyboard;
softKeyboard = new SoftKeyboard(mainLayout, im);
softKeyboard.setSoftKeyboardCallback(new SoftKeyboard.SoftKeyboardChanged() {

@Override
public void onSoftKeyboardHide()  {
    // Code here
}

@Override
public void onSoftKeyboardShow() {
    // Code here
}   
});

/*
Open or close the soft keyboard easily
*/
softKeyboard.openSoftKeyboard();
softKeyboard.closeSoftKeyboard();

/* Prevent memory leaks:*/
@Override
public void onDestroy() {
    super.onDestroy();
    softKeyboard.unRegisterSoftKeyboardCallback();
}

পিএস - পুরোপুরি এখান থেকে নেওয়া ।

Answer 12

ক্ষেত্রে জন্য adjustResize@Jaap থেকে FragmentActivity গৃহীত সমাধান আমার জন্য কাজ করে না।

এখানে আমার সমাধান:

private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
    private int contentDiff;
    private int rootHeight;
    @Override
    public void onGlobalLayout() {
        View contentView = getWindow().findViewById(Window.ID_ANDROID_CONTENT);
        if (rootHeight != mDrawerLayout.getRootView().getHeight()) {
            rootHeight = mDrawerLayout.getRootView().getHeight();
            contentDiff = rootHeight - contentView.getHeight();
            return;
        }
        int newContentDiff = rootHeight - contentView.getHeight();
        if (contentDiff != newContentDiff) {
            if (contentDiff < newContentDiff) {
                onShowKeyboard(newContentDiff - contentDiff);
            } else {
                onHideKeyboard();
            }
            contentDiff = newContentDiff;
        }
    }
};

Answer 13

ব্যবহারকারী কখন টাইপ করা বন্ধ করে দিয়েছে তা পরীক্ষা করে দেখার জন্য একটি ভিন্ন পদ্ধতি হবে ...

যখন একটি পাঠ্য সম্পাদনা ফোকাসে থাকে (ব্যবহারকারী টাইপ করছেন / করছেন) আপনি দর্শনগুলি লুকিয়ে রাখতে পারেন (শ্রোতার ফোকাস)

এবং কীবোর্ডটি (এটির দৃশ্যমান নির্বিশেষে) বন্ধ করতে একটি হ্যান্ডলার + চালিত এবং একটি পাঠ্য পরিবর্তন শ্রোতার ব্যবহার করুন এবং কিছুটা বিলম্বের পরে দর্শনগুলি দেখান।

আপনার সন্ধানের মূল বিষয়টি হ'ল আপনি যে বিলম্ব করবেন তা হ'ল এটি এই পাঠ্য সম্পাদনাগুলির সামগ্রীর উপর নির্ভর করবে।

Handler timeoutHandler = new Handler();
Runnable typingRunnable = new Runnable() {
    public void run() {
        // current TextEdit
        View view = getCurrentFocus();

        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        // reset focus
        view.clearFocus();
        // close keyboard (whether its open or not)
        imm.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.RESULT_UNCHANGED_SHOWN);

        // SET VIEWS VISIBLE
    }
};

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            // SET VIEWS GONE

            // reset handler
            timeoutHandler.removeCallbacks(typingRunnable);
            timeoutHandler.postDelayed(typingRunnable, TYPING_TIMEOUT);
        }
    }
});

editText.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        // Reset Handler...
        timeoutHandler.removeCallbacks(typingRunnable);
    }

    @Override
    public void afterTextChanged(Editable s) {
        // Reset Handler Cont.
        if (editText.getText().toString().trim().length() > 0) {
            timeoutHandler.postDelayed(typingRunnable, TYPING_TIMEOUT);
        }
    }
});

Answer 14

এই কোডটি দুর্দান্ত কাজ করে

মূল দেখার জন্য এই শ্রেণিটি ব্যবহার করুন:

public class KeyboardConstraintLayout extends ConstraintLayout {

private KeyboardListener keyboardListener;
private EditText targetEditText;
private int minKeyboardHeight;
private boolean isShow;

public KeyboardConstraintLayout(Context context) {
    super(context);
    minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height); //128dp
}

public KeyboardConstraintLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
    minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height); // 128dp
}

public KeyboardConstraintLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    minKeyboardHeight = getResources().getDimensionPixelSize(R.dimen.keyboard_min_height); // 128dp
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if (!isInEditMode()) {
        Activity activity = (Activity) getContext();
        @SuppressLint("DrawAllocation")
        Rect rect = new Rect();
        getWindowVisibleDisplayFrame(rect);

        int statusBarHeight = rect.top;
        int keyboardHeight = activity.getWindowManager().getDefaultDisplay().getHeight() - (rect.bottom - rect.top) - statusBarHeight;

        if (keyboardListener != null && targetEditText != null && targetEditText.isFocused()) {
            if (keyboardHeight > minKeyboardHeight) {
                if (!isShow) {
                    isShow = true;
                    keyboardListener.onKeyboardVisibility(true);
                }
            }else {
                if (isShow) {
                    isShow = false;
                    keyboardListener.onKeyboardVisibility(false);
                }
            }
        }
    }
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

public boolean isShowKeyboard() {
    return isShow;
}

public void setKeyboardListener(EditText targetEditText, KeyboardListener keyboardListener) {
    this.targetEditText = targetEditText;
    this.keyboardListener = keyboardListener;
}

public interface KeyboardListener {
    void onKeyboardVisibility (boolean isVisible);
}

}

এবং ক্রিয়াকলাপ বা খণ্ডে কীবোর্ড শ্রোতা সেট করুন:

        rootLayout.setKeyboardListener(targetEditText, new KeyboardConstraintLayout.KeyboardListener() {
        @Override
        public void onKeyboardVisibility(boolean isVisible) {

        }
    });

Answer 15

আপনি আপনার ক্রিয়াকলাপে দুটি পদ্ধতির ওভাররাইড করে কীবোর্ডের দৃশ্যমানতা পরিচালনা করতে পারেন: onKeyUp()এবং onKeyDown()এই লিঙ্কে আরও তথ্য: https://developer.android.com/training/keyboard-input/commands

Comments

দস্তাবেজগুলি হুবহু নির্দিষ্ট করে যে এই ফাংশনগুলি নরম ইনপুট কীবোর্ডের উল্লেখে ব্যবহার করা উচিত নয়।

— পাইওটার প্রুস

Answer 16

দুর্ভাগ্যক্রমে জাপ ভ্যান হেনস্টামের উত্তর সম্পর্কে মন্তব্য করার মতো যথেষ্ট উচ্চ খ্যাতি আমার নেই। তবে আমি লোকদের কয়েকটি মন্তব্য পড়েছি, যে সমস্যাটি contentViewTopসর্বদা 0এবং যা onShowKeyboard(...)সর্বদা ডাকা হয় having

আমার একই সমস্যা ছিল এবং আমার যে সমস্যাটি হয়েছিল তা বের করে ফেললাম। আমি AppCompatActivityএকটি 'নরমাল' এর পরিবর্তে একটি ব্যবহার করেছি Activity। এই ক্ষেত্রে ডান শীর্ষ মান সহ Window.ID_ANDROID_CONTENTএকটি ContentFrameLayoutএবং না বোঝায় FrameLayout। আমার ক্ষেত্রে 'স্বাভাবিক' ব্যবহার করা ভাল ছিল Activity, যদি আপনাকে অন্য ক্রিয়াকলাপ-ধরণের ব্যবহার করতে হয় (আমি কেবল এটি পরীক্ষা করেছি AppCompatActivity, সম্ভবত এটি অন্যান্য অ্যাকটিভি টাইপের মতো সমস্যাও রয়েছে FragmentActivity), আপনাকে অ্যাক্সেস করতে হবে FrameLayout, যা একটি পূর্বপুরুষ ContentFrameLayout।

Answer 17

কীবোর্ড শো যখন

rootLayout.getHeight() < rootLayout.getRootView().getHeight() - getStatusBarHeight() 

সত্য, অন্যথায় আড়াল

Answer 18

private boolean isKeyboardShown = false;
private int prevContentHeight = 0;
private ViewGroup contentLayout;

private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener =
        new ViewTreeObserver.OnGlobalLayoutListener() {

    @Override
    public void onGlobalLayout() {
        int contentHeight = contentLayout.getHeight();
        int rootViewHeight = contentLayout.getRootView().getHeight();

        if (contentHeight > 0) {

            if (!isKeyboardShown) {
                if (contentHeight < prevContentHeight) {
                    isKeyboardShown = true;
                    onShowKeyboard(rootViewHeight - contentHeight);
                }
            } else {
                if (contentHeight > prevContentHeight) {
                    isKeyboardShown = false;
                    onHideKeyboard();
                }
            }

            prevContentHeight = contentHeight;
        }
    }
};

আমি জাপের গ্রহণযোগ্য উত্তরটি কিছুটা পরিবর্তন করেছি। তবে আমার ক্ষেত্রে, এমন কয়েকটি অনুমান যেমন রয়েছে android:windowSoftInputMode=adjustResizeএবং অ্যাপ্লিকেশন শুরু হওয়ার পরে কীবোর্ড শুরুতে প্রদর্শিত হয় না। এবং এছাড়াও, আমি ধরে নিই যে পর্দাটি পিতামাতার উচ্চতার সাথে মিলে।

contentHeight > 0এই চেকটি আমাকে জানতে সরবরাহ করে যে সম্পর্কিত স্ক্রিনটি লুকানো আছে বা এই নির্দিষ্ট স্ক্রিনের জন্য শোনার কীবোর্ড ইভেন্টটি প্রয়োগ করতে দেখানো হয়েছে। এছাড়াও আমি attachKeyboardListeners(<your layout view here>)আমার মূল ক্রিয়াকলাপের onCreate()পদ্ধতিতে স্ক্রীন সম্পর্কিত লেআউট ভিউটি পাস করি । প্রতিবার যখন স্ক্রীন সম্পর্কিত উচ্চতা পরিবর্তিত হয়, prevContentHeightকীবোর্ডটি প্রদর্শিত বা লুকানো আছে কিনা তা পরে পরীক্ষা করতে আমি এটি পরিবর্তনশীলে সংরক্ষণ করি ।

আমার জন্য, এখনও পর্যন্ত এটি বেশ ভালভাবে কাজ করা হয়েছে। আমি আশা করি এটি অন্যদের জন্যও কার্যকর হয়।

Answer 19

"জাপ ভ্যান হেনস্টম" এর উত্তর আমার পক্ষে কাজ করছে, তবে "অ্যান্ড্রয়েড: উইন্ডোসফট ইনপুটমড" সেট করার দরকার নেই ঠিক যেমনটি তিনি বলেছেন!

আমি এটিকে আরও ছোট করে ফেলেছি (এটি এখন আমি কী চাই তা সনাক্ত করে, কীবোর্ডটি দেখানোর এবং লুকানোর বিষয়ে আসলে একটি ঘটনা):

private ViewTreeObserver.OnGlobalLayoutListener keyboardLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        int heightDiff = rootLayout.getRootView().getHeight() - rootLayout.getHeight();
        int contentViewTop = getWindow().findViewById(Window.ID_ANDROID_CONTENT).getTop();
        if(heightDiff <= contentViewTop){
            onHideKeyboard();
        } else {
            onShowKeyboard();
        }
    }
};

private boolean keyboardListenersAttached = false;
private ViewGroup rootLayout;

protected void onShowKeyboard() {}
protected void onHideKeyboard() {}

protected void attachKeyboardListeners() {
    if (keyboardListenersAttached) {
        return;
    }

    rootLayout = (ViewGroup) findViewById(R.id.CommentsActivity);
    rootLayout.getViewTreeObserver().addOnGlobalLayoutListener(keyboardLayoutListener);

    keyboardListenersAttached = true;
}

@Override
protected void onDestroy() {
    super.onDestroy();

    if (keyboardListenersAttached) {
        rootLayout.getViewTreeObserver().removeGlobalOnLayoutListener(keyboardLayoutListener);
    }
}

এবং এই যোগ করতে ভুলবেন না

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_comments);
    attachKeyboardListeners();}

Answer 20

এটি আপনার ক্রিয়াকলাপ পরিবর্তন করার কোনও প্রয়োজন ছাড়াই কাজ করবে android:windowSoftInputMode

পদক্ষেপ 1: এডিট টেক্সট ক্লাস প্রসারিত করুন এবং এই দুটিটিকে ওভাররাইড করুন:

@Override
public void setOnEditorActionListener(final OnEditorActionListener listener) {
    mEditorListener = listener;
    super.setOnEditorActionListener(listener);
}

@Override
public boolean onKeyPreIme(final int keyCode, final KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP) {
        if (mEditorListener != null) {
            mEditorListener.onEditorAction(this, android.R.id.closeButton, event);
        }
    }
    return super.onKeyPreIme(keyCode, event);
}

পদক্ষেপ 2: আপনার ক্রিয়াকলাপে এই দুটি তৈরি করুন:

private void initKeyboard() {
    final AppEditText editText = findViewById(R.id.some_id);
    editText.setOnFocusChangeListener(new OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            setKeyboard(hasFocus);
        }
    });
    editText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (event == null || event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
                editText.clearFocus();
            }
            return false;
        }
    });
}

public void setKeyboard(boolean isShowing) {
    // do something
}

*** clearFocusকাজ করার জন্য মনে রাখবেন , আপনাকে পিতামাতার বা প্রথম সন্তানের পিতামাতার ক্রমবিন্যাসকে মনোনিবেশযোগ্য করতে হবে।

    setFocusableInTouchMode(true);
    setFocusable(true);

Answer 21

এটি পছন্দসই হিসাবে কাজ করছে না ...

... পরীক্ষা করার জন্য অনেকগুলি ব্যবহারের আকারের গণনা দেখেছি ...

আমি এটি খোলার কিনা তা নির্ধারণ করতে চেয়েছিলাম এবং খুঁজে পেয়েছি isAcceptingText()

সুতরাং এটি প্রকৃতপক্ষে প্রশ্নের উত্তর দেয় না কারণ এটি খোলার বা বন্ধ হওয়ার দিকে লক্ষ্য করে না বরং আরও পছন্দ পছন্দ বা বন্ধ রয়েছে তাই এটি সম্পর্কিত কোড যা অন্য পরিস্থিতিতে বিভিন্ন পরিস্থিতিতে সহায়তা করতে পারে ...

একটি ক্রিয়াকলাপে

    if (((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).isAcceptingText()) {
        Log.d(TAG,"Software Keyboard was shown");
    } else {
        Log.d(TAG,"Software Keyboard was not shown");
    }

একটি খণ্ডে

    if (((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).isAcceptingText()) {
        Log.d(TAG,"Software Keyboard was shown");
    } else {
        Log.d(TAG,"Software Keyboard was not shown");

    }

Answer 22

নীচের কোড দিয়ে চেক করুন:

এক্সএমএল কোড:

<android.support.constraint.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/coordinatorParent"
    style="@style/parentLayoutPaddingStyle"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

  .................


</android.support.constraint.ConstraintLayout>

জাভা কোড:

//Global Variable
android.support.constraint.ConstraintLayout activityRootView;
boolean isKeyboardShowing = false;
private  ViewTreeObserver.OnGlobalLayoutListener onGlobalLayoutListener;
android.support.constraint.ConstraintLayout.LayoutParams layoutParams;




 //onCreate or onViewAttached
    activityRootView = view.findViewById(R.id.coordinatorParent);
        onGlobalLayoutListener = onGlobalLayoutListener();
        activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(onGlobalLayoutListener);


  //outside oncreate
  ViewTreeObserver.OnGlobalLayoutListener onGlobalLayoutListener() {
        return new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                Rect r = new Rect();
                activityRootView.getWindowVisibleDisplayFrame(r);
                int screenHeight = activityRootView.getRootView().getHeight();
                int keypadHeight = screenHeight - r.bottom;

                if (keypadHeight > screenHeight * 0.15) { // 0.15 ratio is perhaps enough to determine keypad height.
                    if (!isKeyboardShowing) {  // keyboard is opened
                        isKeyboardShowing = true;
                        onKeyboardVisibilityChanged(true);
                   }
                }
                else {
                    if (isKeyboardShowing) {   // keyboard is closed
                        isKeyboardShowing = false;
                        onKeyboardVisibilityChanged(false);
                    }
                }
            }//ends here
        };

    }


    void onKeyboardVisibilityChanged(boolean value) {
        layoutParams = (android.support.constraint.ConstraintLayout.LayoutParams)topImg.getLayoutParams();

        if(value){
           int length = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 90, getResources().getDisplayMetrics());
            layoutParams.height= length;
            layoutParams.width = length;
            topImg.setLayoutParams(layoutParams);
            Log.i("keyboard " ,""+ value);
        }else{
            int length1 = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 175, getResources().getDisplayMetrics());
            layoutParams.height= length1;
            layoutParams.width = length1;
            topImg.setLayoutParams(layoutParams);
            Log.i("keyboard " ,""+ value);
        }
    }


    @Override
    public void onDetach() {
        super.onDetach();
        if(onGlobalLayoutListener != null) {
            activityRootView.getViewTreeObserver().removeOnGlobalLayoutListener(onGlobalLayoutListener);
        }
    }