অ্যান্ড্রয়েডে সফ্টওয়্যার কীবোর্ডের দৃশ্যমানতা কীভাবে পরীক্ষা করবেন?


516

আমার একটি খুব সাধারণ কাজ করা দরকার - এটি সফ্টওয়্যার কীবোর্ড প্রদর্শিত কিনা তা সন্ধান করুন। অ্যান্ড্রয়েডে এটি কি সম্ভব?


9
যদিও রূবেণ স্ক্র্যাটনের উত্তরটি ভাল তবে এটি ট্যাবলেটে নষ্ট হয়ে গেছে বলে মনে হচ্ছে। আমি চেক ডিফ> 128 কে ডিফ> স্ক্রিনহাইট / 3 এর সাথে প্রতিস্থাপন করেছি।
কিংস্টন

2
রূবেণ স্ক্র্যাটনের উত্তর ভাল ছিল তবে সত্যিকারভাবে এটি ব্যবহার করার জন্য আমার কাছির সমন্বয় প্রয়োজন।
কুলান

1
গুগল কেন কোনও মানসম্মত বিল্টিন পদ্ধতি সব কীবোর্ড অ্যাপ্লিকেশনটির জন্য কাজ করে না?
ফল 17

4
এটি এখনও আমার ভাই, এটি কোনও সিস্টেম ফাংশন নয় ...
লংগি

1
এটি একেবারে বাদাম যে এই এপিআইটি 10 বছর পরেও অনুপস্থিত । আমি খুব আনন্দিত হয়েছি আমি অ্যান্ড্রয়েড থেকে সরে এসেছি।
রূবেন স্ক্র্যাটন

উত্তর:


674

নতুন উত্তর 25 জানুয়ারী 2012 এ যুক্ত হয়েছে

নীচের উত্তরটি লেখার পর থেকে কেউ আমাকে ভিউটি ট্রিউজারবার এবং বন্ধুবান্ধব, এপিআইগুলির অস্তিত্বের কাছে আঁকড়ে ধরেছিল যা সংস্করণ 1 থেকে এসডিকে লুকার করে আসছে।

কাস্টম লেআউট প্রকারের পরিবর্তে, আপনার কার্যকলাপের রুট @+id/activityRootভিউটিকে একটি পরিচিত আইডি দেওয়ার জন্য একটি আরও সহজ সমাধান হ'ল বলুন , একটি গ্লোবাল লেআউটলিস্টনারকে ভিউট্রিঅবার্সারে হুক করুন এবং সেখান থেকে আপনার ক্রিয়াকলাপের ভিউ রুট এবং উইন্ডো আকারের মধ্যে আকারের পার্থক্য গণনা করুন:

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();
        if (heightDiff > dpToPx(this, 200)) { // if more than 200 dp, it's probably a keyboard...
            // ... do something here
        }
     }
});

ইউটিলিটি ব্যবহার করে যেমন:

public static float dpToPx(Context context, float valueInDp) {
    DisplayMetrics metrics = context.getResources().getDisplayMetrics();
    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, metrics);
}

সহজ!

দ্রষ্টব্য: আপনার অ্যাপ্লিকেশনটিকে অবশ্যই এই পতাকাটি অ্যান্ড্রয়েড ম্যানিফেস্টে সেট করতে হবে android:windowSoftInputMode="adjustResize"অন্যথায় উপরের সমাধানগুলি কাজ করবে না।

মূল উত্তর

হ্যাঁ এটি সম্ভব, তবে এটি হওয়া উচিত তার চেয়ে শক্ত।

যদি কীবোর্ডটি উপস্থিত হয় এবং অদৃশ্য হয়ে যায় (যা প্রায়শই প্রায়শই ঘটে) সেদিকে যদি আমার যত্ন নেওয়া দরকার তবে আমি যা করি তা আমার শীর্ষ স্তরের লেআউট শ্রেণিকে কাস্টমাইজ করে যা ওভাররাইড হয় onMeasure()। মূল যুক্তিটি হ'ল যদি যদি বিন্যাসটি উইন্ডোর মোট ক্ষেত্রের তুলনায় উল্লেখযোগ্যভাবে কম পূরণ করে তবে একটি নরম কীবোর্ড সম্ভবত প্রদর্শিত হচ্ছে।

import android.app.Activity;
import android.content.Context;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.widget.LinearLayout;

/*
 * LinearLayoutThatDetectsSoftKeyboard - a variant of LinearLayout that can detect when 
 * the soft keyboard is shown and hidden (something Android can't tell you, weirdly). 
 */

public class LinearLayoutThatDetectsSoftKeyboard extends LinearLayout {

    public LinearLayoutThatDetectsSoftKeyboard(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public interface Listener {
        public void onSoftKeyboardShown(boolean isShowing);
    }
    private Listener listener;
    public void setListener(Listener listener) {
        this.listener = listener;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int height = MeasureSpec.getSize(heightMeasureSpec);
        Activity activity = (Activity)getContext();
        Rect rect = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(rect);
        int statusBarHeight = rect.top;
        int screenHeight = activity.getWindowManager().getDefaultDisplay().getHeight();
        int diff = (screenHeight - statusBarHeight) - height;
        if (listener != null) {
            listener.onSoftKeyboardShown(diff>128); // assume all soft keyboards are at least 128 pixels high
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);       
    }

    }

তারপরে আপনার ক্রিয়াকলাপ শ্রেণিতে ...

public class MyActivity extends Activity implements LinearLayoutThatDetectsSoftKeyboard.Listener {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        LinearLayoutThatDetectsSoftKeyboard mainLayout = (LinearLayoutThatDetectsSoftKeyboard)findViewById(R.id.main);
        mainLayout.setListener(this);
        ...
    }


    @Override
    public void onSoftKeyboardShown(boolean isShowing) {
        // do whatever you need to do here
    }

    ...
}

62
এটি আমার পক্ষে কাজ করছে না যতক্ষণ না বুঝেছি যে আপনি অবশ্যই আপনার ক্রিয়াকলাপে নিম্নলিখিত গুণাবলী নির্ধারণ করতে পারেন: অ্যান্ড্রয়েড: উইন্ডোসফট ইনপুটমোড = "অ্যাডজাস্টারাইজ করুন"
আজ

9
মনে হচ্ছে কৌতুকটি করছে। এছাড়াও, যদি আপনি রুট ভিউটির আইডি না জানেন তবে আপনি কীভাবে ভিউটি পেতে পারেন তা এখানে:((ViewGroup) findViewById(android.R.id.content)).getChildAt(0)
স্বর্ণকার

8
আপনি যদি আসল রুট ভিউ ( android.R.id.content) ব্যবহার করে এটি ব্যবহার করে দেখে থাকেন তবে আপনি আরও আত্মবিশ্বাসের সাথে বলতে সক্ষম হবেন যে Systemআপনার অ্যাপ্লিকেশন না হয়ে বরং তার দৈর্ঘ্যের উচ্চতা পরিবর্তনকারী সত্তা। অ্যান্ড্রয়েড দলের পক্ষে আমাদের বিরতি দেওয়ার জন্য আরও নিরাপদ হবে এবং সফটকিবোর্ড ইনপুট সম্পর্কে কমপক্ষে প্রাথমিক বিষয়গুলি আমাদের জানান।
গ্রীম

14
সাবধান থাকুন যাতে heightDiffঅ্যাকশন বারের উচ্চতা সর্বদা অন্তর্ভুক্ত থাকে। নতুন উত্তরে যা পরীক্ষার দ্বারা অগ্রাহ্য করা হয়েছে যদি সেই উচ্চতা কিছু ধ্রুবকের চেয়ে বেশি হয় তবে নেক্সাস ৪ এর মতো xxhdpi ডিভাইসের জন্য ১০০ পিক্সেল যথেষ্ট নয় তবে আপনি যদি সত্যই এই হ্যাকি ওয়ার্কটি ব্যবহার করতে চান তবে সেই মানটিকে ডিপিতে রূপান্তর করতে বিবেচনা করুন- কাছাকাছি.
পল ল্যামার্টসমা

8
বিজ্ঞপ্তি: উইন্ডোম্যানেজ.লায়আউটপ্যারামস.এফএলএজি_এফএলএলএসসিরেইন এবং পূর্ণ স্ক্রিন থিম সহ কাজ করছেন না।
ভিএভি

303

সুতরাং আশা করি এটি কাউকে সাহায্য করবে।

রূবেন স্ক্র্যাটন যে নতুন উত্তর দিয়েছে তা দুর্দান্ত এবং সত্যিই দক্ষ, তবে আপনি যদি উইন্ডো সাফট ইনপুটমোডকে সামঞ্জস্য করতে পুনরায় সেট করেন তবে এটি কার্যকরভাবেই কাজ করবে। যদি আপনি এটি অ্যাডজাস্টপ্যানে সেট করেন তবে তার কোড স্নিপেট ব্যবহার করে কীবোর্ড দৃশ্যমান কিনা তা এখনও সনাক্ত করা সম্ভব নয়। এটির চারপাশে কাজ করার জন্য, আমি উপরের কোডটিতে এই ক্ষুদ্র পরিবর্তন করেছি।

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    activityRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
    if (heightDiff > 0.25*activityRootView.getRootView().getHeight()) { // if more than 25% of the screen, its probably a keyboard...
        ... do something here
    }
 }
}); 

1
এটি আমার জন্য কাজ করেছে। আমি stackoverflow.com/a/5224088/530513 এরTwoDScrollerView অনুরূপ কাস্টম থেকে কীবোর্ডের অবস্থা সনাক্ত করার চেষ্টা করছিলাম যদিও জুমিংয়ের সাথেও। শিশুটি সাধারণ নয়, একটি কাস্টম বিন্যাস (প্রসারিত ) ছিল তবে সেটিংস সত্ত্বেও প্রস্তাবিত সমাধান ব্যবহার করে কীবোর্ড সনাক্ত করতে অক্ষম । ধন্যবাদ! ImageViewRelativeLayoutandroid:windowSoftInputMode="adjustResize"
ডেভিড ও'মিয়ারা

1
আপনাকে ধন্যবাদ, আপনাকে ধন্যবাদ আপনাকে ধন্যবাদ! অ্যাডজাস্টাইজ করা কেবলমাত্র আমার অ্যাপ্লিকেশনটির জন্য কার্যকর নয় এবং আপনার সমাধানটি পুরোপুরি কার্যকর হয়েছিল।
dwemthy

1
ActionBarএবং সঙ্গে কাজ করে ActionBarSherlock। অনেক ধন্যবাদ! যাইহোক, একটি পদ্ধতি আছে r.height():)
দিমিত্রি জায়েতসেভ

1
এই উত্তরটি কোনওভাবে চিহ্নিত করতে আমি ২৩ ঘন্টার মধ্যে এখানে একটি অনুদান সংযুক্ত করব।
দিমিত্রি জায়েতসেভ

9
heightDiff > root.getRootView().getHeight() / 4উচ্চ রেজোলিউশন ডিভাইসের সাথে কাজ করার জন্য ভাল মান। 100px সংক্ষেপে। 1920x - (996-75)> এর সাথে নেক্সাস 5 এ? 100 = 999 1920 - (1776-75)>? 100 = 219 // কীবোর্ড 480x800 রেজিস, 800 - (800-88)> এর সাথে গ্যালাক্সি এস 2 এ রয়েছে? 100 = 38 800 - (410-38)>? 100 = 428 // কীবোর্ড আপ তাই, ম্যাজিক সংখ্যা 100px যথেষ্ট ভাল নয়।
ফ্লাস্ক_কেআর

55

এটি কম্পিউটারের ক্ষেত্রে সর্বদা ছিল তবে এই প্রশ্নটি এখনও অবিশ্বাস্যভাবে প্রাসঙ্গিক!

সুতরাং আমি উপরের উত্তরগুলি নিয়েছি এবং সেগুলি কিছুটা সংযুক্ত এবং পরিমার্জন করেছি ...

public interface OnKeyboardVisibilityListener {


    void onVisibilityChanged(boolean visible);
}

public final void setKeyboardListener(final OnKeyboardVisibilityListener listener) {
    final View activityRootView = ((ViewGroup) getActivity().findViewById(android.R.id.content)).getChildAt(0);

    activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

        private boolean wasOpened;

        private final int DefaultKeyboardDP = 100;

        // From @nathanielwolf answer...  Lollipop includes button bar in the root. Add height of button bar (48dp) to maxDiff
        private final int EstimatedKeyboardDP = DefaultKeyboardDP + (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ? 48 : 0);

        private final Rect r = new Rect();

        @Override
        public void onGlobalLayout() {
            // Convert the dp to pixels.
            int estimatedKeyboardHeight = (int) TypedValue
                    .applyDimension(TypedValue.COMPLEX_UNIT_DIP, EstimatedKeyboardDP, activityRootView.getResources().getDisplayMetrics());

            // Conclude whether the keyboard is shown or not.
            activityRootView.getWindowVisibleDisplayFrame(r);
            int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
            boolean isShown = heightDiff >= estimatedKeyboardHeight;

            if (isShown == wasOpened) {
                Log.d("Keyboard state", "Ignoring global layout change...");
                return;
            }

            wasOpened = isShown;
            listener.onVisibilityChanged(isShown);
        }
    });
}

আমার জন্য কাজ কর :)

দ্রষ্টব্য: আপনি যদি লক্ষ্য করেন যে DefaultKeyboardDP আপনার ডিভাইসটির মানটি মানের সাথে ফিট করে না এবং মানটির কী হওয়া উচিত তা জানতে প্রত্যেকের জন্য একটি মন্তব্য পোস্ট করুন ... অবশেষে আমরা সমস্ত ডিভাইসকে ফিট করার জন্য সঠিক মানটি পেয়ে যাব!

আরও তথ্যের জন্য, সাইবার্গে বাস্তবায়নটি দেখুন


2
+1 আপনাকে অনেক ধন্যবাদ !! আমি অন্য উত্তরগুলি চেষ্টা করছিলাম, কিন্তু সেগুলি কার্যকর হয় না। তারপরে আমি আপনার খুঁজে পেয়েছি এবং এটি একটি কবজির মতো কাজ করে। অসাধারণ কোড! : ডি
কেভিন ভ্যান মিয়ার্লো

এটি কেবল যুক্ত করলেই এটি কাজ করে: অ্যান্ড্রয়েড: উইন্ডোসফটআইনপুটমোড = "স্টেটহিডেন | অ্যাডজাস্টপ্যান" বা অ্যান্ড্রয়েড: উইন্ডোসফটআইপুটমোড = "স্টেটহিডেন | অ্যাডজাস্ট্রাইজ করুন" ধন্যবাদ আপনাকে !!!!
লেনা ব্রু

তুমি কি নিশ্চিত? যদি মেমোরি সার্ভারগুলি থাকে তবে অ্যান্ড্রয়েড: উইন্ডোসফট ইনপুটমোডের ডিফল্ট মান ছিল ... আমি যে জিনিসটি কাজ করি নি তা হ'ল পর্দার আচরণ, তাই আমি ম্যানুয়ালি এটিকে সঙ্কুচিত করলাম ...
TacB0sS

2
একটি ছোট সংশোধন: বেসরকারী চূড়ান্ত int EstimatedKeyboardDP = DefaultKeyboardDP + (বিল্ড.VERSION.SDK_INT> = বিল্ড.VERSION_CODES.LOLLIPOP? 48: 0);
বাইনারি কার্মিক

2
চমৎকার !! "উইন্ডোজসফট ইনপুটমোড" "অ্যাডজাস্টপ্যান" / "অ্যাডজাস্টারাইজাইজ" / "অ্যাডজাস্টপ্যান | স্টেটহিডেন" / "অ্যাডজাস্টারাইজ | স্টেটহিডেন" এ সেট করা আছে বা এই বিকল্পটি ছাড়াই এটি সর্বদা কাজ করে! জিয়াওমি ৮.
ঝো হংকবো

52

দেরিতে জবাবের জন্য দুঃখিত, তবে শ্রোতাদের এবং অন্যান্য দরকারী বিষয়গুলিকে অবহিত করার সাথে খোলা / ঘনিষ্ঠ ইভেন্টগুলি পরিচালনা করতে আমি একটু সহায়ক শ্রেণি তৈরি করেছিলাম, কারওর পক্ষে এটি সহায়ক হতে পারে:

import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver;

import java.util.LinkedList;
import java.util.List;

public class SoftKeyboardStateWatcher implements ViewTreeObserver.OnGlobalLayoutListener {

    public interface SoftKeyboardStateListener {
        void onSoftKeyboardOpened(int keyboardHeightInPx);
        void onSoftKeyboardClosed();
    }

    private final List<SoftKeyboardStateListener> listeners = new LinkedList<SoftKeyboardStateListener>();
    private final View activityRootView;
    private int        lastSoftKeyboardHeightInPx;
    private boolean    isSoftKeyboardOpened;

    public SoftKeyboardStateWatcher(View activityRootView) {
        this(activityRootView, false);
    }

    public SoftKeyboardStateWatcher(View activityRootView, boolean isSoftKeyboardOpened) {
        this.activityRootView     = activityRootView;
        this.isSoftKeyboardOpened = isSoftKeyboardOpened;
        activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(this);
    }

    @Override
    public void onGlobalLayout() {
        final Rect r = new Rect();
        //r will be populated with the coordinates of your view that area still visible.
        activityRootView.getWindowVisibleDisplayFrame(r);

        final int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
        if (!isSoftKeyboardOpened && heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...
            isSoftKeyboardOpened = true;
            notifyOnSoftKeyboardOpened(heightDiff);
        } else if (isSoftKeyboardOpened && heightDiff < 100) {
            isSoftKeyboardOpened = false;
            notifyOnSoftKeyboardClosed();
        }
    }

    public void setIsSoftKeyboardOpened(boolean isSoftKeyboardOpened) {
        this.isSoftKeyboardOpened = isSoftKeyboardOpened;
    }

    public boolean isSoftKeyboardOpened() {
        return isSoftKeyboardOpened;
    }

    /**
     * Default value is zero {@code 0}.
     *
     * @return last saved keyboard height in px
     */
    public int getLastSoftKeyboardHeightInPx() {
        return lastSoftKeyboardHeightInPx;
    }

    public void addSoftKeyboardStateListener(SoftKeyboardStateListener listener) {
        listeners.add(listener);
    }

    public void removeSoftKeyboardStateListener(SoftKeyboardStateListener listener) {
        listeners.remove(listener);
    }

    private void notifyOnSoftKeyboardOpened(int keyboardHeightInPx) {
        this.lastSoftKeyboardHeightInPx = keyboardHeightInPx;

        for (SoftKeyboardStateListener listener : listeners) {
            if (listener != null) {
                listener.onSoftKeyboardOpened(keyboardHeightInPx);
            }
        }
    }

    private void notifyOnSoftKeyboardClosed() {
        for (SoftKeyboardStateListener listener : listeners) {
            if (listener != null) {
                listener.onSoftKeyboardClosed();
            }
        }
    }
}

ব্যবহারের উদাহরণ:

final SoftKeyboardStateWatcher softKeyboardStateWatcher 
    = new SoftKeyboardStateWatcher(findViewById(R.id.activity_main_layout);

// Add listener
softKeyboardStateWatcher.addSoftKeyboardStateListener(...);
// then just handle callbacks

2
ক্লাসটি অল্প নয় তবে বাস্তবায়ন অবশ্যই :)। ধন্যবাদ আমি এটি চেষ্টা করব :)
অতুল হে হোলিক

1
আপনার যদি সমস্যা হয় তবে আমাকে পিং করুন :) আমি এটি সফলভাবে 2 টি প্রকল্পে ব্যবহার করেছি
আর্টেম জিনাতুল্লিন

উপরোক্ত অনেকগুলি উদাহরণ চেষ্টা করার পরে এবং ছোটখাটো সমস্যার মধ্যে চলে যাওয়ার পরে, এই একটাই আমার পক্ষে অনেকগুলি বিভিন্ন ডিভাইস (xxhdpi সহ) জুড়ে সবচেয়ে ভাল কাজ করেছে। প্লাস এটি নিজস্ব সুন্দর পুনরায় ব্যবহারযোগ্য শ্রেণিতে। আমি এটিকে রূপান্তর করলাম মনো ড্রয়েডে ব্যবহার করার জন্য।
খেতে

কিছু কিছু কীবোর্ড, কিছু সময়ের উপরে শীর্ষে কাস্টম কীগুলির অতিরিক্ত সারি থাকে (উদাহরণস্বরূপ, পূর্বাভাসযুক্ত শব্দ)। এগুলি আপাতদৃষ্টিতে নিজেরাই কীবোর্ডের অংশ নয়, যেহেতু getLastKeyboardHeightInPx()এই সারিটির উচ্চতা অন্তর্ভুক্ত নয়। এটিকেও আমলে নেওয়ার কোনও উপায় কি আপনি জানেন?
ygeher

এটি কেবল তখনই কার্যকর হয় যখন আপনি কীবোর্ড প্রদর্শিত হলে বিন্যাসের উচ্চতা পরিবর্তনের সাথে আপোস করতে প্রস্তুত হন। ঠিক আছে?
এম উসমান খান

33

উচ্চ ঘনত্ব ডিভাইসে ভুলভাবে সফ্ট কীবোর্ডের দৃশ্যমানতা এড়াতে কিছু উন্নতি হয়েছে:

  1. উচ্চতার পার্থক্যের প্রান্তিকতা 128 পিক্সেল নয়, 128 ডিপি হিসাবে সংজ্ঞায়িত করা উচিত । পড়ুন মেট্রিক্স এবং গ্রিড সম্পর্কে Google নকশা ডক , 48 ডিপি স্পর্শ বস্তুর জন্য আরামদায়ক আকার এবং 32 ডিপি বোতামের জন্য সর্বনিম্ন। জেনেরিক সফট কীবোর্ডে 4 টি সারি কী বোতাম অন্তর্ভুক্ত করা উচিত, তাই সর্বনিম্ন কীবোর্ডের উচ্চতা হওয়া উচিত: 32 ডিপি * 4 = 128 ডিপি , যার অর্থ থ্রেশহোল্ডের আকারটি বহুগুণ ডিভাইসের ঘনত্বের মাধ্যমে পিক্সেলগুলিতে স্থানান্তর করা উচিত। এক্সএক্সএক্সএইচডিপি ডিভাইসগুলির জন্য (ঘনত্ব 4), নরম কীবোর্ড উচ্চতা প্রান্তিক হওয়া উচিত 128 * 4 = 512 পিক্সেল।

  2. রুট ভিউ এবং এর দৃশ্যমান ক্ষেত্রের মধ্যে উচ্চতা পার্থক্য:
    রুট ভিউ উচ্চতা - স্ট্যাটাস বারের উচ্চতা - দৃশ্যমান ফ্রেমের উচ্চতা = রুট ভিউ নীচে - দৃশ্যমান ফ্রেমের নীচে, যেহেতু স্ট্যাটাস বারের উচ্চতা রুট ভিউ দৃশ্যমান ফ্রেমের শীর্ষের সমান।

    private final String TAG = "TextEditor";
    private TextView mTextEditor;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_editor);
        mTextEditor = (TextView) findViewById(R.id.text_editor);
        mTextEditor.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                isKeyboardShown(mTextEditor.getRootView());
            }
        });
    }
    
    private boolean isKeyboardShown(View rootView) {
        /* 128dp = 32dp * 4, minimum button height 32dp and generic 4 rows soft keyboard */
        final int SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD = 128;
    
        Rect r = new Rect();
        rootView.getWindowVisibleDisplayFrame(r);
        DisplayMetrics dm = rootView.getResources().getDisplayMetrics();
        /* heightDiff = rootView height - status bar height (r.top) - visible frame height (r.bottom - r.top) */
        int heightDiff = rootView.getBottom() - r.bottom;
        /* Threshold size: dp to pixels, multiply with display density */
        boolean isKeyboardShown = heightDiff > SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD * dm.density;
    
        Log.d(TAG, "isKeyboardShown ? " + isKeyboardShown + ", heightDiff:" + heightDiff + ", density:" + dm.density
                + "root view height:" + rootView.getHeight() + ", rect:" + r);
    
        return isKeyboardShown;
    }

4
এটি গ্রহণযোগ্য উত্তর পাওয়ার যোগ্য। ঘনত্ব উপেক্ষা করে আমাকে বিভিন্ন ফর্ম ফ্যাক্টরগুলির সাথে একই রকম পিক্সেল আকারের ডিভাইসে খুব আলাদা ফলাফল দিয়েছে। ধন্যবাদ!
আদা ম্যাকমুরে

2
ধন্যবাদ ... এটি আরও উন্নত অবস্থা!
TacB0sS

1
চমৎকার। #KeboardShown () পদ্ধতিটি আমাদের প্রয়োজন। ধন্যবাদ
ড্যানিয়েলো ভলোক

এটি ২০২০ সালেও কাজ করছে। নিখুঁত উত্তর. আমি সমস্ত কোড চেষ্টা করেছিলাম কিন্তু এটিতে পুরোপুরি কাজ করে works
মিতেশ জৈন

8

আমি এটি বের করার জন্য কিছুটা সময় ব্যবহার করেছি ... আমি এটির জন্য কিছু কাস্টেক্সেপশন চালিয়েছি, তবে বুঝতে পেরেছি যে আপনি ক্লাসের নামের সাথে বিন্যাস.এক্সএমএলতে লিনিয়ারলআউটকে প্রতিস্থাপন করতে পারেন।

এটার মত:

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout android:layout_width="fill_parent" android:layout_height="fill_parent"
    xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/llMaster">

<com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard android:background="@drawable/metal_background"
    android:layout_width="fill_parent" android:layout_height="fill_parent"
    android:id="@+id/rlMaster" >
    <LinearLayout android:layout_width="fill_parent"
        android:layout_height="1dip" android:background="@drawable/line"></LinearLayout>

          ....

</com.ourshoppingnote.RelativeLayoutThatDetectsSoftKeyboard>    


</LinearLayout>

এইভাবে আপনি কোনও castালাইয়ের সমস্যা নিয়ে চলবেন না।

... এবং আপনি যদি প্রতিটি পৃষ্ঠায় এটি করতে না চান তবে আমি আপনাকে "অ্যান্ড্রয়েডে মাস্টারপেজ" ব্যবহার করার পরামর্শ দিচ্ছি। লিঙ্কটি এখানে দেখুন: http://jnastase.alner.net/archive/2011/01/08/ldquomaster-pagesrdquo-in-android.aspx


বাহ যদি আপনার একই প্যাকেজ / শ্রেণীর নাম না থাকে তবে আপনার এক্সএমএলে এটি আটকে দেওয়ার বিষয়ে সতর্ক হন। গ্রহপ সবেমাত্র স্থির করার সিদ্ধান্ত নেয় এবং আপনাকে এটি বন্ধ করতে হবে। যেমন একটি পেশাদার পণ্য। / গুলি
স্পেনসার রূপর

5
@ স্পেন্সারআরপোর্ট, এ কারণেই এটি বিনামূল্যে।
কোডি

@ ডক্টরওরিও - ইন্টেলিজি পান। এটি বিনামূল্যে এবং স্তন্যপান না।
চিহ্নিত করুন

@ মার্ক - আমি এটি পোস্ট করার কয়েক মাস পরে আমি প্রকৃতপক্ষে ইন্টেলিজিকে চেষ্টা করেছিলাম। এটি আইএমও, গ্রহণের চেয়ে অনেক ভাল। তাদের সমস্ত পণ্য (বেশিরভাগ অংশের জন্য) আমি মনে করি দুর্দান্ত। এমনকি কয়েকটা কিনেছি।
কোডি

এই ধরনের একটি পুরানো মন্তব্য থ্রেড পুনরুদ্ধার জন্য দুঃখিত। আপনি এটি ব্যবহার করে এবং এটি উপভোগ করছেন তাতে আমি আনন্দিত। আমি ইন্টেলিজের পাশাপাশি আইওএসের অ্যাপকোড এবং পাইথন কাজের জন্য পাইচার্ম ব্যবহার করতে পছন্দ করি। চিয়ার্স!
চিহ্নিত করুন

7

উপাদানগুলির উচ্চতা চেক করা নির্ভরযোগ্য নয় কারণ কিছু কিছু কীবোর্ড যেমন উইফাইকিবোর্ডের উচ্চতা শূন্য থাকে।

পরিবর্তে, আপনি কীবোর্ডের স্থিতি পরীক্ষা করতে শোসফট ইনপুট () এবং হাইডসফট ইনপুট () এর কলব্যাক ফলাফল ব্যবহার করতে পারেন। সম্পূর্ণ বিবরণ এবং উদাহরণ কোড

https://rogerkeays.com/how-to-check-if-the-software-keyboard-is-shown-in-android


5

ধারণাটি হ'ল, যদি আপনার একই সাথে আপনার কীবোর্ডটি লুকিয়ে রাখতে এবং নরম ইনপুট স্থিতি পরীক্ষা করতে হয় তবে নিম্নলিখিত সমাধানটি ব্যবহার করুন:

public boolean hideSoftInput() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
    return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);
}

লুকানোর আগে কীবোর্ড দেখানো হলে এই পদ্ধতিটি সত্য হয়।


এটি হ'ল উচ্চতা এবং সমস্ত ব্যবহার না করেই কাজ করে ... ধন্যবাদ ... আপনি আমার সময় বাঁচিয়েছেন ...
ভিজি

4

আমি দেখতে পেয়েছি যে @ যোগেশের পদ্ধতির সাথে @ রূবেন_সক্রাটনের পদ্ধতির সংমিশ্রণটি সেরা কাজ করে বলে মনে হচ্ছে। তাদের পদ্ধতিগুলির সংমিশ্রণে এ জাতীয় কিছু পাওয়া যাবে:

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
  @Override
  public void onGlobalLayout() {
    if (getResources().getConfiguration().keyboardHidden == Configuration.KEYBOARDHIDDEN_NO) { // Check if keyboard is not hidden
       // ... do something here
    }
  }
});

সর্বদা কনফিগারেশন.কিওয়াইবিআরডিএইচডিএন_না।
কল্পনা

4

ক্রিয়াকলাপের সজ্জাভিউ ব্যবহার করে আপনি সফটকিবোর্ডের লুকগুলি পর্যবেক্ষণ করতে পারেন।

public final class SoftKeyboardUtil {
    public static final String TAG = "SoftKeyboardUtil";
    public static void observeSoftKeyBoard(Activity activity , final OnSoftKeyBoardHideListener listener){
        final View decorView = activity.getWindow().getDecorView();
        decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                Rect rect = new Rect();
                decorView.getWindowVisibleDisplayFrame(rect);
                int displayHight = rect.bottom - rect.top;
                int hight = decorView.getHeight();
                boolean hide = (double)displayHight / hight > 0.8 ;
                if(Log.isLoggable(TAG, Log.DEBUG)){
                    Log.d(TAG ,"DecorView display hight = "+displayHight);
                    Log.d(TAG ,"DecorView hight = "+ hight);
                    Log.d(TAG, "softkeyboard visible = " + !hide);
                }

                listener.onSoftKeyBoardVisible(!hide);

            }
        });
    }



    public interface OnSoftKeyBoardHideListener{
        void onSoftKeyBoardVisible(boolean visible);
    }
}

4

পার্থক্য কোডিং ধরে নেওয়ার পরিবর্তে আমি এরকম কিছু করেছি, কারণ আমার অ্যাপ্লিকেশনটিতে আমার মেনু অপশন ছিল।

final View root= findViewById(R.id.myrootview); 
root.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
    public void onGlobalLayout() {
        int heightDiff = root.getRootView().getHeight() - root.getHeight();

        Rect rectgle= new Rect();
        Window window= getWindow();
        window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
        int contentViewTop=                     
          window.findViewById(Window.ID_ANDROID_CONTENT).getTop();
        if(heightDiff <= contentViewTop){
            //Soft KeyBoard Hidden
        }else{
            //Soft KeyBoard Shown
        }
     }
});

এটি অ্যান্ড্রয়েডের জন্য কাজ করে না: উইন্ডোসফট ইনপুটমড = "অ্যাডজাস্টপ্যান"। আমি চেয়েছিলাম যে সফট কীবোর্ড প্রদর্শিত হওয়ার পরে আমার স্ক্রিনটি সঙ্কুচিত না হওয়া উচিত। আপনি দয়া করে কোনও স্থিরতা বলতে পারেন যাতে এটি অ্যাডজাস্টপ্যানের জন্যও কার্যকর হয়
শিরিশ হার্ভাড

4

সিস্টেম ইনসেটগুলির সাথে সমাধানও রয়েছে তবে এটি কেবল API >= 21( Android L) দিয়ে কাজ করে । বলুন যে আপনার BottomNavigationViewযা আছে LinearLayoutএবং এটি কীবোর্ড দেখানোর সময় আপনার এটি আড়াল করা দরকার:

> LinearLayout
  > ContentView
  > BottomNavigationView

আপনাকে যা করতে হবে তা হ'ল LinearLayoutএইভাবে প্রসারিত করা:

public class KeyboardAwareLinearLayout extends LinearLayout {
    public KeyboardAwareLinearLayout(Context context) {
        super(context);
    }

    public KeyboardAwareLinearLayout(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public KeyboardAwareLinearLayout(Context context,
                                     @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public KeyboardAwareLinearLayout(Context context, AttributeSet attrs,
                                     int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    public WindowInsets onApplyWindowInsets(WindowInsets insets) {
        int childCount = getChildCount();
        for (int index = 0; index < childCount; index++) {
            View view = getChildAt(index);
            if (view instanceof BottomNavigationView) {
                int bottom = insets.getSystemWindowInsetBottom();
                if (bottom >= ViewUtils.dpToPx(200)) {
                    // keyboard is shown
                    view.setVisibility(GONE);
                } else {
                    // keyboard is hidden
                    view.setVisibility(VISIBLE);
                }
            }
        }
        return insets;
    }
}

ধারণাটি হ'ল যখন কীবোর্ড প্রদর্শিত হয়, তখন সিস্টেমের ইনসেটগুলি বেশ বড় .bottomমান দিয়ে পরিবর্তন করা হয়।


4

এর জন্য একটি গোপন পদ্ধতি সাহায্য করতে পারে InputMethodManager.getInputMethodWindowVisibleHeight,। তবে কেন জানি এটি লুকিয়ে আছে।

import android.content.Context
import android.os.Handler
import android.view.inputmethod.InputMethodManager

class SoftKeyboardStateWatcher(private val ctx: Context) {
  companion object {
    private const val DELAY = 10L
  }

  private val handler = Handler()
  private var isSoftKeyboardOpened: Boolean = false

  private val height: Int
    get() {
      val imm = ctx.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
      val method = imm.javaClass.getMethod("getInputMethodWindowVisibleHeight")
      method.isAccessible = true
      return method.invoke(imm) as Int
    }

  private val task: Runnable by lazy {
    Runnable {
      start()
      if (!isSoftKeyboardOpened && height > 0) {
        isSoftKeyboardOpened = true
        notifyOnSoftKeyboardOpened(height)
      } else if (isSoftKeyboardOpened && height == 0) {
        isSoftKeyboardOpened = false
        notifyOnSoftKeyboardClosed()
      }
    }
  }

  var listener: SoftKeyboardStateListener? = null

  interface SoftKeyboardStateListener {
    fun onSoftKeyboardOpened(keyboardHeightInPx: Int)
    fun onSoftKeyboardClosed()
  }

  fun start() {
    handler.postDelayed(task, DELAY)
  }

  fun stop() {
    handler.postDelayed({
      if (!isSoftKeyboardOpened) handler.removeCallbacks(task)
    }, DELAY * 10)
  }

  private fun notifyOnSoftKeyboardOpened(keyboardHeightInPx: Int) {
    listener?.onSoftKeyboardOpened(keyboardHeightInPx)
  }

  private fun notifyOnSoftKeyboardClosed() {
    listener?.onSoftKeyboardClosed()
  }
}

যদি কারও এটির প্রয়োজন হয় - এটি জামারিনেও কাজ করে, পদ্ধতির নামটি হুবহু এবং একইভাবে প্রবেশ করা দরকার - ইনপুটমেথডম্যানেজারের শ্রেণি সম্পত্তি দ্বারা।
কনস্ট্যান্টিন সেভেরি

এটি ব্যবহারে সতর্কতা অবলম্বন করুন, এটি অসমর্থিত এপিআই (এটি কোনও কারণে লুকানো রয়েছে) এবং প্রারম্ভিকদের জন্য এটি KitKat এ কাজ করে না।
ড্যানিয়েল রিচি

3

এই সমাধানগুলির কোনওটি ললিপপের মতো যেমন কাজ করবে না। ললিপপটিতে activityRootView.getRootView().getHeight()বোতামের বারের উচ্চতা অন্তর্ভুক্ত থাকে, যখন ভিউটি পরিমাপ করে না। ললিপপের সাথে কাজ করার জন্য আমি উপরের সেরা / সহজ সমাধানটি মানিয়ে নিয়েছি।

    final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
  @Override
  public void onGlobalLayout() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    activityRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
    Resources res = getResources();
    // The status bar is 25dp, use 50dp for assurance
    float maxDiff =
        TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 50, res.getDisplayMetrics());

    //Lollipop includes button bar in the root. Add height of button bar (48dp) to maxDiff
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
      float buttonBarHeight =
          TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 48, res.getDisplayMetrics());
      maxDiff += buttonBarHeight;
    }
    if (heightDiff > maxDiff) { // if more than 100 pixels, its probably a keyboard...
      ...do something here
    }
  }
});

আপনার জন্য স্ট্যাকওভারফ্লো.com/ a/ 18992807/2914140 কাজ করে না কেন এবং কীভাবে আপনার সমাধানটি পৃথক হয়?
কুলমাইন্ড

3

উপরের বেশিরভাগ সমাধান ব্যবহার করার সময় আমি একটি বাগের মুখোমুখি হয়েছি যা একটি নির্দিষ্ট নম্বর যুক্ত করার পরামর্শ দেয়।

এস 4-তে একটি উচ্চ ডিপিআই রয়েছে যার ফলে নেভিগেশন বারের উচ্চতা 100px হয়েছিল ফলে আমার অ্যাপটি এই ভেবে যে সমস্ত সময় কীবোর্ডটি খোলা থাকে।

তাই সমস্ত নতুন হাই রেজোল্ট ফোন প্রকাশের সাথে সাথে আমি বিশ্বাস করি যে হার্ড কোডিং মানটি দীর্ঘমেয়াদী ব্যবহার করা ভাল নয়।

আরও ভাল পন্থা যা আমি বিভিন্ন স্ক্রিন এবং ডিভাইসে কিছু পরীক্ষার পরে পেয়েছি তা শতাংশ ব্যবহার করা। সজ্জাভিউ এবং আপনার অ্যাপ্লিকেশন সামগ্রীর মধ্যে পার্থক্য পান এবং তারপরে সেই পার্থক্যের শতাংশ কত তা পরীক্ষা করে দেখুন। আমি যে পরিসংখ্যান পেয়েছি তা থেকে, বেশিরভাগ ন্যাভ বার (আকার, রেজোলিউশন ইত্যাদি নির্বিশেষে) পর্দার 3% থেকে 5% এর মধ্যে নেবে। যেখানে যেন কীবোর্ডটি খোলা থাকে তবে এটি স্ক্রিনের 47% থেকে 55% এর মধ্যেই নেয়।

উপসংহার হিসাবে আমার সমাধানটি ছিল 10% এর বেশি পার্থক্য কিনা তা যাচাই করা হয়েছিল তবে আমি এটির একটি কীবোর্ড উন্মুক্ত বলে ধরেছি।


3

আমি রূবানের উত্তরের কিছুটা বৈকল্পিক ব্যবহার করেছি, যা নির্দিষ্ট পরিস্থিতিতে বিশেষত উচ্চ রেজোলিউশন ডিভাইসগুলির সাথে আরও সহায়ক বলে প্রমাণিত হয়েছিল।

final View activityRootView = findViewById(android.R.id.content);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(
        new OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                int heightView = activityRootView.getHeight();
                int widthView = activityRootView.getWidth();
                if (1.0 * widthView / heightView > 3) {
                    //Make changes for Keyboard not visible
                } else {
                    //Make changes for keyboard visible
                }
            }
        });

এই আর.আইডি.অ্যাক্টিভিটি
রুটটি

2
তৈরি এবং ব্যবহারের পরিবর্তে R.id.activityRoot, আপনি কেবল android.R.id.contentযা আপনার প্রয়োজন ঠিক তেমন ব্যবহার করতে পারেন ।
মার্সিন ওরোলোস্কি

3

এটি কম্পিউটারের ক্ষেত্রে সর্বদা ছিল তবে এই প্রশ্নটি এখনও অবিশ্বাস্যভাবে প্রাসঙ্গিক! সুতরাং আমি উপরের উত্তরগুলি নিয়েছি এবং সেগুলি কিছুটা সংযুক্ত এবং পরিমার্জন করেছি ...

public interface OnKeyboardVisibilityListener {
    void onVisibilityChanged(boolean visible);
}

public final void setKeyboardListener(final OnKeyboardVisibilityListener listener) {
    final View activityRootView = ((ViewGroup) getActivity().findViewById(android.R.id.content)).getChildAt(0);
    activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

        private boolean wasOpened;

    private final Rect r = new Rect();

        @Override
        public void onGlobalLayout() {
            activityRootView.getWindowVisibleDisplayFrame(r);

            int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
            boolean isOpen = heightDiff > 100;
            if (isOpen == wasOpened) {
                logDebug("Ignoring global layout change...");
                return;
            }

            wasOpened = isOpen;
            listener.onVisibilityChanged(isOpen);
        }
    });
}

এটা আমার জন্য কাজ করে.


3

এটা চেষ্টা কর:

final View activityRootView = getWindow().getDecorView().getRootView();
activityRootView.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.
        activityRootView.getWindowVisibleDisplayFrame(r);

        int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
        if (heightDiff < activityRootView.getRootView().getHeight() / 4 ) { // if more than 100 pixels, its probably a keyboard...
             // ... do something here ... \\
        }
    }
});

2

আমার উত্তরটি মূলত কচির জবাবের সমান, তবে আমার অ্যাপ্লিকেশনটিতে এটি যেভাবে ব্যবহৃত হয়েছে তা পরিষ্কার করার জন্য আমি এটিকে একটি চমৎকার সহায়ক শ্রেণিতে আবদ্ধ করি।

import android.app.Activity;
import android.app.Fragment;
import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;

/**
 * Detects Keyboard Status changes and fires events only once for each change
 */
public class KeyboardStatusDetector {
    KeyboardVisibilityListener visibilityListener;

    boolean keyboardVisible = false;

    public void registerFragment(Fragment f) {
        registerView(f.getView());
    }

    public void registerActivity(Activity a) {
        registerView(a.getWindow().getDecorView().findViewById(android.R.id.content));
    }

    public KeyboardStatusDetector registerView(final View v) {
        v.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                Rect r = new Rect();
                v.getWindowVisibleDisplayFrame(r);

                int heightDiff = v.getRootView().getHeight() - (r.bottom - r.top);
                if (heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...
                    /** Check this variable to debounce layout events */
                    if(!keyboardVisible) {
                        keyboardVisible = true;
                        if(visibilityListener != null) visibilityListener.onVisibilityChanged(true);
                    }
                } else {
                    if(keyboardVisible) {
                        keyboardVisible = false;
                        if(visibilityListener != null) visibilityListener.onVisibilityChanged(false);
                    }
                }
            }
        });

        return this;
    }

    public KeyboardStatusDetector setVisibilityListener(KeyboardVisibilityListener listener) {
        visibilityListener = listener;
        return this;
    }

    public static interface KeyboardVisibilityListener {
        public void onVisibilityChanged(boolean keyboardVisible);
    }
}

আপনি অ্যাপ্লিকেশন জুড়ে যে কোনও জায়গায় কীবোর্ড পরিবর্তনগুলি সনাক্ত করতে এটি ব্যবহার করতে পারেন:

    new KeyboardStatusDetector()
            .registerFragment(fragment)  //register to a fragment 
            .registerActivity(activity)  //or register to an activity
            .registerView(view)          //or register to a view
            .setVisibilityListener(new KeyboardVisibilityListener() {
                @Override
                public void onVisibilityChanged(boolean keyboardVisible) {
                    if(keyboardVisible) {
                       //Do stuff for keyboard visible
                    }else {
                       //Do stuff for keyboard hidden
                    }
                }
            });

দ্রষ্টব্য: কেবলমাত্র "নিবন্ধক" কলগুলির মধ্যে একটি ব্যবহার করুন। তারা সবাই একই রকম কাজ করে এবং কেবল সুবিধার জন্য সেখানে


2

আপনি এটি চেষ্টা করতে পারেন, আমার জন্য দুর্দান্ত কাজ করুন:

InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);

if (imm.isAcceptingText()) {
    //Software Keyboard was shown..
} else {
    //Software Keyboard was not shown..
}

1
এটি ব্যবহার করবেন না, এটি
কীওয়ার্ডটি

2
সর্বদা দৃশ্যমান প্রতিক্রিয়া
jose920405

2

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

এক্ষেত্রে কীবোর্ডের স্থিতি বজায় রাখতে প্রথমে আপনারটিতে যুক্ত android:windowSoftInputMode = "stateUnchanged"করা উচিত AndroidManifest.xml। আপনি খেয়াল করতে পারেন, যদিও, এটি আসলে পুরো সমস্যাটি সমাধান করে না - প্রাচ্য পরিবর্তনের আগে কীবোর্ডটি আগে খোলা থাকলে এটি আমার জন্য খোলেনি। অন্য সমস্ত ক্ষেত্রে, আচরণটি সঠিক বলে মনে হয়েছিল।

তারপরে, আমাদের এখানে বর্ণিত সমাধানগুলির একটি প্রয়োগ করতে হবে। আমি সবচেয়ে পরিষ্কার খুঁজে পেয়েছি হ'ল জর্জ মাইসুরাডজে - হাইডসফট ইনপুটফর্মউইন্ডো থেকে বুলিয়ান কলব্যাক ব্যবহার করুন:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
return imm.hideSoftInputFromWindow(mViewPager.getWindowToken(), 0);

আমি আমার ফ্রেগমেন্টের onSaveInstanceStateপদ্ধতিতে এই মানটি সঞ্চয় করে এটিকে পুনরুদ্ধার করেছি onCreate। তারপরে, আমি জোর করে কীবোর্ডটি এর onCreateViewমান দেখিয়ে দেখিয়েছি true(ফ্রেগমেন্ট ধ্বংসের পূর্বে কীবোর্ডটি এটি লুকানোর আগে দৃশ্যমান হলে সত্য হয়)।


1

এখানে আমার সমাধান, এবং এটি কার্যকর হয়। পিক্সেল আকারের পরিবর্তে অনুসন্ধান করে দেখুন যে সামগ্রীর দৃশ্যের উচ্চতা পরিবর্তন হয়েছে কি না:

// Scroll to the latest comment whenever the keyboard is shown
commentsContent.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

        private int oldHeight;

        @Override
        public void onGlobalLayout() {
            int newHeight = commentsContent.getMeasuredHeight();
            if (newHeight < oldHeight) {
                // Check for the keyboard showing in case the height difference
                // is a result of orientation change
                if (isSoftKeyboardShowing(CommentsActivity.this)) {
                    // Keyboard is showing so scroll to the latest comment
                    scrollToLatestComment();
                }
            }
            oldHeight = newHeight;
        }

    });


public static boolean isSoftKeyboardShowing(Activity activity) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    return inputMethodManager.isActive();
}

ইনপুটমেডোড ম্যানেজ.আইআরসিটিভ () কীবোর্ডটি চালু আছে বা না তা নির্বিশেষে আমার জন্য সর্বদা সত্য ফিরে আসছে
ইয়নরব

1

কোনও হার্ড কোড করবেন না। সেরা উপায় হ'ল কীবোর্ড শো সহ এডিটেক্সট ফোকাসে থাকাকালীন আপনার নিজের মতামতগুলির আকার পরিবর্তন করতে হবে। আপনি নীচের কোডটি ব্যবহার করে ম্যানিফেস্ট ফাইলে ক্রিয়াকলাপে থাকা সম্পত্তির পুনরায় আকার যুক্ত করে এটি করতে পারেন।

android:windowSoftInputMode="adjustResize"


1

এটি সন্ধানের জন্য সরাসরি পদ্ধতি রয়েছে। এবং এটির জন্য কোনও লেআউট পরিবর্তন প্রয়োজন হয় না।
সুতরাং, এটি নিমজ্জনিত পূর্ণস্ক্রিন মোডেও কাজ করে।

কৌশলটি হ'ল আপনি নরম কীবোর্ডটি লুকানোর বা দেখানোর চেষ্টা করছেন এবং সেই চেষ্টাটির ফলাফল ক্যাপচার করুন।
কোনও আতঙ্ক নেই, এটি সত্যিই কীবোর্ডটি দেখায় বা আড়াল করে না। আমরা শুধু রাষ্ট্র চাই।

আপ টু ডেট থাকার জন্য, আপনি হ্যান্ডলার ব্যবহার করে সহজেই অপারেশনটি পুনরায় করতে পারেন, যেমন প্রতি 200 মিলিসেকেন্ড।

আপনি এখানে একটি বাস্তবায়ন পাবেন: https://stackoverflow.com/a/27567074/2525452


1

আমি মনে করি এই পদ্ধতিটি আপনাকে কী-বোর্ডটি দৃশ্যমান কিনা তা খুঁজে পেতে সহায়তা করবে।

 public Boolean isSoftKeyBoardVisible(){
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);

    if (imm.isAcceptingText()) {
        Log.d(TAG,"Software Keyboard was shown");
        return true;
    } else {
        Log.d(TAG,"Software Keyboard was not shown");
        return false;
    }

}

সর্বদা দৃশ্যমান প্রতিক্রিয়া
jose920405

0

রূবেন স্ক্র্যাটনের নতুন উত্তর (হাইটডিফ গণনা করুন int heightDiff = activityRootView.getRootView().getHeight() - activityRootView.getHeight();) ক্রিয়াকলাপে কাজ করবে না যদি আপনি ট্রান্সলুসেন্ট স্ট্যাটাস বার মোড সেট করেন।

যদি আপনি স্বচ্ছ স্থিতি বার ব্যবহার করেন তবে activityRootView.getHeight()কখনই আবহাওয়ার পরিবর্তন হবে না সফট কীবোর্ড দৃশ্যমান। এটি সর্বদা ক্রিয়াকলাপ এবং স্থিতি দণ্ডের উচ্চতা ফিরিয়ে আনবে।

উদাহরণস্বরূপ, Nexus 4, Android 5.0.1, সেট android:windowTranslucentStatus করা সত্য হয়েছে, এটি চিরকালের জন্য 1184 ফিরে আসবে, এমনকি আইমও খুলেছে। আপনি যদি সেটandroid:windowTranslucentStatus করেন তবে এটি উচ্চতাটি সঠিকভাবে ফিরে আসবে, যদি আইএম অদৃশ্য হয় তবে এটি 1134 ফেরত আসবে (স্ট্যাটাস বারটি অন্তর্ভুক্ত নয়) - আইম বন্ধ করুন, এটি 5xx ফিরে আসবে (আইমের উচ্চতার উপর নির্ভর করে)

আমি জানি না আবহাওয়া এটি একটি বাগ, আমি চেষ্টা করেছি 4.4.4 এবং 5.0.1, ফলাফল একই is

সুতরাং, এখন অবধি, দ্বিতীয় সর্বাধিক সম্মত উত্তর, কাচের সমাধান আইমের উচ্চতা গণনা করা সবচেয়ে নিরাপদ উপায়। এখানে একটি অনুলিপি:

final View activityRootView = findViewById(R.id.activityRoot);
activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new        OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
Rect r = new Rect();
//r will be populated with the coordinates of your view that area still visible.
activityRootView.getWindowVisibleDisplayFrame(r);

int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
if (heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...
    ... do something here
    }
 }
}); 

0

একটি পদ্ধতি যে লেআউটলিস্টনারের প্রয়োজন হয় না

আমার ক্ষেত্রে, আমি আমার খণ্ডটি প্রতিস্থাপনের আগে কীবোর্ডের অবস্থাটি সংরক্ষণ করতে চাই। আমি এই পদ্ধতিটি গোপনে সাফট ইনপুটফ্রিনড উইন্ডো থেকে কল করি onSaveInstanceState , যা কীবোর্ডটি বন্ধ করে দেয় এবং কীবোর্ডটি দৃশ্যমান ছিল কি না তা আমাকে ফিরিয়ে দেয়।

এই পদ্ধতিটি সহজবোধ্য তবে আপনার কীবোর্ডের অবস্থার পরিবর্তন করতে পারে।


0

আমি জানি যে এটি একটি পুরাতন পোস্ট তবে আমি মনে করি এটি আমার জানা সবচেয়ে সহজ পদ্ধতির এবং আমার পরীক্ষার ডিভাইসটি নেক্সাস ৫ I আমি অন্যান্য ডিভাইসে এটি চেষ্টা করি নি। আশা করি অন্যরা যদি তাদের কোডটি ভাল না দেখতে পান তবে তাদের মতামতটি ভাগ করে নেবেন :)

public static boolean isKeyboardShown(Context context, View view) {
        if (context == null || view == null) {
            return false;
        }
        InputMethodManager imm = (InputMethodManager) context
                .getSystemService(Context.INPUT_METHOD_SERVICE);
        return imm.hideSoftInputFromWindow(view.getWindowToken(), 0); 
}

im.hideSoftInputFromWindow বুলিয়ান দেয়।

ধন্যবাদ,


0
if (keyopen())
{
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);            
}

উপরের ফাংশনটি হ'ল আমি কোনও কী-বোর্ড দৃশ্যমান কিনা তা যাচাই করতে ব্যবহার করি। যদি তা হয় তবে আমি এটি বন্ধ করে দিই।

নীচে দুটি প্রয়োজনীয় পদ্ধতি দেখায়।

প্রথমে, ওনক্রিটটিতে কার্যক্ষম উইন্ডোটির উচ্চতা নির্ধারণ করুন।

protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

//  add to onCreate method
    Rect rectgle= new Rect();
    Window window= getWindow();
    window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
    sheight= rectgle.bottom;
//

} 

তারপরে, একটি বুলিয়ান পদ্ধতি যুক্ত করুন যা সেই পরিস্থিতিতে উইন্ডোটির উচ্চতা পায়। যদি এটি আসলটির সাথে মেলে না (ধরে নিই যে আপনি এটির সাথে এটি পরিবর্তন করছেন না ...) তবে কীবোর্ডটি খোলা রয়েছে।

public boolean keyopen()
{
    Rect rectgle= new Rect();
    Window window= getWindow();
    window.getDecorView().getWindowVisibleDisplayFrame(rectgle);
    int curheight= rectgle.bottom;

    if (curheight!=sheight)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Frotz!


0

আমি জানি কীবোর্ডটি লুকিয়ে আছে কিনা আপনি কতটা সঠিক তা নির্ধারণ করতে পারেন।

public int getStatusBarHeight() {
    int result = 0;
    int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
    if (resourceId > 0) {
        result = getResources().getDimensionPixelSize(resourceId);
    }
    return result;
}

public int getNavigationBarHeight() {
    int result = 0;
    int resourceId = getResources().getIdentifier("navigation_bar_height", "dimen", "android");
    if (resourceId > 0) {
        result = getResources().getDimensionPixelSize(resourceId);
    }
    return result;
}

public boolean isKeyboardHidden() {
    int delta = mRootView.getRootView().getHeight() - mRootView.getHeight() - getNavigationBarHeight() - getStatusBarHeight()
            - getSupportActionBar().getHeight();
    return delta <= 0;
}

এটি ট্যাবলেটগুলির জন্য কাজ করে। যখন নেভিগেশন বার অনুভূমিকভাবে প্রদর্শিত হবে।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.