windowSoftInputMode = "AdjustResize" não está funcionando com ação translúcida / navbar


129

Estou com problemas com a barra de ação translúcida / navbar no novo Android KitKat (4.4) e no windowSoftInputMode="adjustResize".

Alterando normalmente o InputMode para AdjustResize, o aplicativo deve se redimensionar quando o teclado é mostrado ... mas aqui não! Se eu excluir as linhas do efeito transparente, o redimensionamento estará funcionando.

Portanto, se o teclado estiver visível, meu ListView estará embaixo dele e não consigo acessar os últimos itens. (Apenas ocultando o teclado manualmente)

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="XYZ"
android:versionCode="23"
android:versionName="0.1" >

<uses-sdk
    android:minSdkVersion="9"
    android:targetSdkVersion="19" />

<application
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/Theme.XYZStyle" >
    <activity
        android:name="XYZ"
        android:label="@string/app_name"
        android:windowSoftInputMode="adjustResize" >
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

</manifest>

values-v19 / styles.xml

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

<style name="Theme.XYZStyle" parent="@style/Theme.AppCompat.Light">
    <item name="android:windowTranslucentStatus">true</item>
    <item name="android:windowTranslucentNavigation">true</item>
</style>

</resources>

fragment.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<ListView
    android:id="@+id/listView_contacts"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clipToPadding="false"
    android:divider="@null"
    android:dividerHeight="0dp"
    android:drawSelectorOnTop="true"
    android:fastScrollAlwaysVisible="true"
    android:fastScrollEnabled="true"
    android:paddingBottom="@dimen/navigationbar__height" >
</ListView>

</RelativeLayout>

Alguém tem alguma idéia para consertar isso?


Respostas:


184

Está faltando a seguinte propriedade:

android:fitsSystemWindows="true"

na raiz RelativeLayoutdo layout do fragmento .xml.

Atualizar:

No ano passado, houve uma conversa interessante de Chris Bane, que explica detalhadamente como isso funciona:

https://www.youtube.com/watch?v=_mGDMVRO3iE


5
Eu acho que é algo com a política de tela cheia
Felix

1
Você é o cara! Eu esse problema aconteceu comigo apenas na versão Lollipop, e corrigi-lo.
David

6
@ David É nt ainda definidos, ainda quebrando no dispositivo de marshmallow, se você abrir um diálogo e tentar rolar então softkeboard irá bloquear a rolagem
Bytecode

5
Ele funciona, mas o conflito com a minha barra de ferramentas e personalização de estado
Ninja

2
funciona, mas a barra de status não é mais translúcida. Quero que o layout cubra a tela inteira.
Htafoya 15/0118

34

Há um relatório de bug relacionado aqui . Eu encontrei uma solução alternativa que, a partir de testes limitados, parece fazer o truque sem repercussões. Adicione uma implementação personalizada da sua raiz ViewGroup(quase sempre estou usando FrameLayout, então é isso que eu testei) com a lógica abaixo. Em seguida, use esse layout personalizado no lugar do layout raiz e verifique se você o definiu android:fitsSystemWindows="true". Você pode simplesmente ligar a getInsets()qualquer momento após o layout (por exemplo, adicionar um OnPreDrawListener) para ajustar o restante do layout para considerar as inserções do sistema, se desejado.

import android.content.Context;
import android.graphics.Rect;
import android.os.Build;
import android.util.AttributeSet;
import android.widget.FrameLayout;
import org.jetbrains.annotations.NotNull;

/**
 * @author Kevin
 *         Date Created: 3/7/14
 *
 * https://code.google.com/p/android/issues/detail?id=63777
 * 
 * When using a translucent status bar on API 19+, the window will not
 * resize to make room for input methods (i.e.
 * {@link android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_RESIZE} and
 * {@link android.view.WindowManager.LayoutParams#SOFT_INPUT_ADJUST_PAN} are
 * ignored).
 * 
 * To work around this; override {@link #fitSystemWindows(android.graphics.Rect)},
 * capture and override the system insets, and then call through to FrameLayout's
 * implementation.
 * 
 * For reasons yet unknown, modifying the bottom inset causes this workaround to
 * fail. Modifying the top, left, and right insets works as expected.
 */
public final class CustomInsetsFrameLayout extends FrameLayout {
    private int[] mInsets = new int[4];

    public CustomInsetsFrameLayout(Context context) {
        super(context);
    }

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

    public CustomInsetsFrameLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public final int[] getInsets() {
        return mInsets;
    }

    @Override
    protected final boolean fitSystemWindows(@NotNull Rect insets) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            // Intentionally do not modify the bottom inset. For some reason, 
            // if the bottom inset is modified, window resizing stops working.
            // TODO: Figure out why.

            mInsets[0] = insets.left;
            mInsets[1] = insets.top;
            mInsets[2] = insets.right;

            insets.left = 0;
            insets.top = 0;
            insets.right = 0;
        }

        return super.fitSystemWindows(insets);
    }
}

Como fitSystemWindows foi descontinuado, consulte a resposta abaixo para concluir a solução alternativa.


1
Na verdade, SOFT_INPUT_ADJUST_PAN NÃO parece ser ignorado de acordo com a minha experiência - ele moverá a tela inteira para cima, incluindo a barra do sistema e o teclado de deslocamento sob a visão focada.
sealskej

Obrigado - você está correto sobre o SOFT_INPUT_ADJUST_PAN. Eu usei isso no meu fragmento: getActivity (). GetWindow (). SetSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
Simon

Essa foi a única maneira que eu consegui ajustando o tamanho da atividade (necessário para a rolagem da visualização ao mostrar o teclado), fitSystemWindows definido como true, para que a rolagem realmente ocorra em> = Lollipop e com statusBar translúcido. Muito obrigado.
Lucas

esta é a solução real
martyglaubitz

Está demorando para mostrar e ocultar o teclado, mesmo que demore para aumentar o layout. Qualquer solução ?
Vanjara Sweta 26/07/19

28

A resposta @kcoppock é realmente útil, mas o fitSystemWindows foi descontinuado no nível 20 da API

Portanto, desde a API 20 (KITKAT_WATCH), você deve substituir onApplyWindowInsets

@Override
public final WindowInsets onApplyWindowInsets(WindowInsets insets) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
        return super.onApplyWindowInsets(insets.replaceSystemWindowInsets(0, 0, 0,
                insets.getSystemWindowInsetBottom()));
    } else {
        return insets;
    }
}

Em que classe devemos substituir isso?
Ben-J

@ Ben-J numa classe que se estende de classe original
Victor91

Eu não tenho idéia por que você definir os elementos de matriz mInsets enquanto ele não é usado, mas funciona
Buckstabue

1
Em vez da verificação de versão, você pode usarViewCompat.setOnApplyWindowInsetsListener
repitch

Eu não poderia começar este trabalho, mas substituindo dispatchApplyWindowInsetsvez (mesmo código) trabalhou para mim
Petter

11

Isso funcionou para mim ter barra de status translúcida e AdjustResize no fragmento:

  1. Faça um RelativeLayout personalizado como @ Victor91 e @kcoppock disseram.

  2. Use CustomRelativeLayout como layout pai para seu fragmento.

  3. Declarar o tema com o android: windowTranslucentStatus = true

  4. A atividade do contêiner deve ser declarada no manifesto com android: windowSoftInputMode = "AdjustResize" e usar o tema declarado

  5. Use fitsSystemWindows no layout da raiz do fragmento!

    public class CustomRelativeLayout extends RelativeLayout {
    
        private int[] mInsets = new int[4];
    
        public CustomRelativeLayout(Context context) {
            super(context);
        }
    
        public CustomRelativeLayout(Context context, AttributeSet attrs) {
            super(context, attrs);
        }
    
        public CustomRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
        }
    
        public CustomRelativeLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
            super(context, attrs, defStyleAttr, defStyleRes);
        }
    
        @Override
        public final WindowInsets onApplyWindowInsets(WindowInsets insets) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
                mInsets[0] = insets.getSystemWindowInsetLeft();
                mInsets[1] = insets.getSystemWindowInsetTop();
                mInsets[2] = insets.getSystemWindowInsetRight();
                return super.onApplyWindowInsets(insets.replaceSystemWindowInsets(0, 0, 0,
                        insets.getSystemWindowInsetBottom()));
            } else {
                return insets;
            }
        }
    }

Em seguida, em xml,

<com.blah.blah.CustomRelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:fitsSystemWindows="true">
</com.blah.blah.CustomRelativeLayout>

1
Esta é a melhor resposta até agora, e estou procurando uma solução já há algum tempo. Está funcionando perfeitamente, mas você tem que adicionar algum estofamento extra para sua barra de ferramentas, sem que sua barra de ferramentas será sobreposição de estado
Paulina

E quanto a windowTranslucentNavigation? Você pode me ajudar com isso?
V-rund Puro-hit

10

Se você deseja personalizar as inserções e está direcionando o nível da API> = 21, é possível fazer isso sem precisar criar um grupo de visualizações personalizadas. Apenas definindo o fitsSystemWindowspreenchimento será aplicado à visualização do contêiner por padrão, o que você pode não querer.

As verificações de versão são incorporadas a esse método e apenas os dispositivos> = 21 executam o código dentro do lambda. Exemplo de Kotlin:

ViewCompat.setOnApplyWindowInsetsListener(container) { view, insets ->
  insets.replaceSystemWindowInsets(0, 0, 0, insets.systemWindowInsetBottom).apply {
    ViewCompat.onApplyWindowInsets(view, this)
  }
}

Verifique se o layout ainda define o fitsSystemWindowssinalizador, caso contrário o ouvinte de inserção de janela não será chamado.

<FrameLayout
    android:id="@+id/container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    />

Essas fontes são úteis:

https://medium.com/google-developers/why-would-i-want-to-fitssystemwindows-4e26d9ce1eec https://medium.com/@azizbekian/windowinsets-24e241d4afb9


1
Essa ainda é a melhor abordagem, já que você pode aplicar essa é a sua BaseFragment, juntamente com view.fitsSystemWindows = truee ela simplesmente funciona sem nenhuma alteração nos layouts XML reais ou nas subclasses View.
Bogdan Zurac 21/03/19

5

Eu tive o mesmo problema, Minha atividade tinha um ScrollView como visualização raiz e, com a barra de status translúcida ativada, não foi redimensionada corretamente quando o teclado apareceu ... e, com facilidade, a tela não rolou ocultando as visualizações de entrada.

Solução: movi tudo (lógica de layout e atividade) dentro de um novo fragmento. Em seguida, alterou a atividade para incluir apenas este fragmento. Agora tudo funciona como esperado!

Este é o layout da atividade:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"

    android:id="@+id/contentView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true" />

Funciona como um encanto para mim
imike

2

Com base na solução alternativa de Joseph Johnson no Android Como ajustar o layout no modo de tela cheia quando o teclado virtual está visível

chame isso onCreate()depois setContentView()em sua atividade.

AndroidBug5497Workaround.assistActivity(this);

um diferente litte do original substituir return (r.bottom - r.top);com return r.bottom;nocomputeUsableHeight()

por algum motivo, devo definir meu fitsSystemWindowsatributo de atividade como false.

essa solução alternativa me salvou. Funciona bem para mim. a esperança pode ajudá-lo.

a classe de implementação é:

public class AndroidBug5497Workaround {

// For more information, see https://code.google.com/p/android/issues/detail?id=5497
// To use this class, simply invoke assistActivity() on an Activity that already has its content view set.

public static void assistActivity (Activity activity) {
    new AndroidBug5497Workaround(activity);
}

private View mChildOfContent;
private int usableHeightPrevious;
private FrameLayout.LayoutParams frameLayoutParams;

private AndroidBug5497Workaround(Activity activity) {
    FrameLayout content = (FrameLayout) activity.findViewById(android.R.id.content);
    mChildOfContent = content.getChildAt(0);
    mChildOfContent.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
        public void onGlobalLayout() {
            possiblyResizeChildOfContent();
        }
    });
    frameLayoutParams = (FrameLayout.LayoutParams) mChildOfContent.getLayoutParams();
}

private void possiblyResizeChildOfContent() {
    int usableHeightNow = computeUsableHeight();
    if (usableHeightNow != usableHeightPrevious) {
        int usableHeightSansKeyboard = mChildOfContent.getRootView().getHeight();
        int heightDifference = usableHeightSansKeyboard - usableHeightNow;
        if (heightDifference > (usableHeightSansKeyboard/4)) {
            // keyboard probably just became visible
            frameLayoutParams.height = usableHeightSansKeyboard - heightDifference;
        } else {
            // keyboard probably just became hidden
            frameLayoutParams.height = usableHeightSansKeyboard;
        }
        mChildOfContent.requestLayout();
        usableHeightPrevious = usableHeightNow;
    }
}

private int computeUsableHeight() {
    Rect r = new Rect();
    mChildOfContent.getWindowVisibleDisplayFrame(r);
    return r.bottom;
}

}


0

AndroidBug5497Workaround.java cuide de vazamentos de memória. precisa do código abaixo

getViewTreeObserver().removeOnGlobalLayoutListener(listener);

Minha amostra usando RxJava que chama automaticamente removeOnGlobalLayoutListener () quando onPause () no ciclo de vida da atividade

public class MyActivity extends RxAppCompatActivity {
    // ...

protected void onStart(){
    super.onStart();

        TRSoftKeyboardVisibility
            .changes(this) // activity
            .compose(this.<TRSoftKeyboardVisibility.ChangeEvent>bindUntilEvent(ActivityEvent.PAUSE))
            .subscribe(keyboardEvent -> {
                FrameLayout content = (FrameLayout) findViewById(android.R.id.content);
                View firstChildView = content.getChildAt(0);
                firstChildView.getLayoutParams().height = keyboardEvent.viewHeight();
                firstChildView.requestLayout();

                // keyboardEvent.isVisible      = keyboard visible or not
                // keyboardEvent.keyboardHeight = keyboard height
                // keyboardEvent.viewHeight     = fullWindowHeight - keyboardHeight
            });
   //...
}





package commonlib.rxjava.keyboard;

import android.app.Activity;
import android.view.View;
import android.widget.FrameLayout;
import kr.ohlab.android.util.Assert;
import rx.Observable;

public class TRSoftKeyboardVisibility {

    public static Observable<ChangeEvent> changes(Activity activity) {
        Assert.notNull(activity, "activity == null");
        FrameLayout content = (FrameLayout) activity.findViewById(android.R.id.content);
        View childOfContent = content.getChildAt(0);
        return Observable.create(
            new TRSoftKeyboardVisibilityEventOnSubscribe(childOfContent));
    }

    public static final class ChangeEvent {
        private final int keyboardHeight;
        private final boolean visible;
        private final int viewHeight;

        public static ChangeEvent create(boolean visible, int keyboardHeight,
            int windowDisplayHeight) {
            return new ChangeEvent(visible, keyboardHeight, windowDisplayHeight);
        }

        private ChangeEvent(boolean visible, int keyboardHeight, int viewHeight) {
            this.keyboardHeight = keyboardHeight;
            this.visible = visible;
            this.viewHeight = viewHeight;
        }

        public int keyboardHeight() {
            return keyboardHeight;
        }

        public boolean isVisible() {
            return this.visible;
        }

        public int viewHeight() {
            return viewHeight;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof ChangeEvent)) return false;

            ChangeEvent that = (ChangeEvent) o;

            if (keyboardHeight != that.keyboardHeight) return false;
            if (visible != that.visible) return false;
            return viewHeight == that.viewHeight;
        }

        @Override
        public int hashCode() {
            int result = keyboardHeight;
            result = 31 * result + (visible ? 1 : 0);
            result = 31 * result + viewHeight;
            return result;
        }

        @Override
        public String toString() {
            return "ChangeEvent{" +
                "keyboardHeight=" + keyboardHeight +
                ", visible=" + visible +
                ", viewHeight=" + viewHeight +
                '}';
        }
    }
}


package commonlib.rxjava.keyboard;

import android.graphics.Rect;
import android.view.View;
import android.view.ViewTreeObserver;
import kr.ohlab.android.util.Assert;
import rx.Observable;
import rx.Subscriber;
import rx.android.MainThreadSubscription;
import timber.log.Timber;

public class TRSoftKeyboardVisibilityEventOnSubscribe
    implements Observable.OnSubscribe<TRSoftKeyboardVisibility.ChangeEvent> {
    private final View mTopView;
    private int mLastVisibleDecorViewHeight;
    private final Rect mWindowVisibleDisplayFrame = new Rect();

    public TRSoftKeyboardVisibilityEventOnSubscribe(View topView) {
        mTopView = topView;
    }

    private int computeWindowFrameHeight() {
        mTopView.getWindowVisibleDisplayFrame(mWindowVisibleDisplayFrame);
        return (mWindowVisibleDisplayFrame.bottom - mWindowVisibleDisplayFrame.top);
    }

    private TRSoftKeyboardVisibility.ChangeEvent checkKeyboardVisibility() {
        int windowFrameHeightNow = computeWindowFrameHeight();
        TRSoftKeyboardVisibility.ChangeEvent event = null;
        if (windowFrameHeightNow != mLastVisibleDecorViewHeight) {
            int mTopViewHeight = mTopView.getHeight();
            int heightDiff = mTopViewHeight - windowFrameHeightNow;
            Timber.e("XXX heightDiff=" + heightDiff);
            if (heightDiff > (mTopViewHeight / 4)) {
                event = TRSoftKeyboardVisibility.ChangeEvent.create(true, heightDiff, windowFrameHeightNow);
            } else {
                event = TRSoftKeyboardVisibility.ChangeEvent.create(false, 0, windowFrameHeightNow);
            }
            mLastVisibleDecorViewHeight = windowFrameHeightNow;
            return event;
        }

        return null;
    }

    public void call(final Subscriber<? super TRSoftKeyboardVisibility.ChangeEvent> subscriber) {
        Assert.checkUiThread();

        final ViewTreeObserver.OnGlobalLayoutListener listener =
            new ViewTreeObserver.OnGlobalLayoutListener() {
                @Override
                public void onGlobalLayout() {
                    TRSoftKeyboardVisibility.ChangeEvent event = checkKeyboardVisibility();
                    if( event == null)
                        return;
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext(event);
                    }
                }
            };

        mTopView.getViewTreeObserver().addOnGlobalLayoutListener(listener);

        subscriber.add(new MainThreadSubscription() {
            @Override
            protected void onUnsubscribe() {
                mTopView.getViewTreeObserver().removeOnGlobalLayoutListener(listener);
            }
        });
    }
}

0

Eu tive um problema.

Defino windowDrawsSystemBarBackgrounds como 'true' e meu aplicativo deve aparecer na barra de status.

É o meu tema de atividade.

<item name="android:windowTranslucentStatus" tools:targetApi="KITKAT">false</item>
<item name="android:windowDrawsSystemBarBackgrounds">true</item>
<item name="android:windowTranslucentNavigation">true</item>
<item name="android:statusBarColor">@android:color/transparent</item>

e recebi ajuda do blog de jianshu . você pode ler código, mas texto como eu. Eu adiciono mais alguns códigos.

public final class ZeroInsetsFrameLayout extends FrameLayout {
    private int[] mInsets = new int[4];

    public ZeroInsetsFrameLayout(Context context) {
        super(context);
    }

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

    public ZeroInsetsFrameLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public final int[] getInsets() {
        return mInsets;
    }

    @Override
    public WindowInsets computeSystemWindowInsets(WindowInsets in, Rect outLocalInsets) {
        outLocalInsets.left = 0;
        outLocalInsets.top = 0;
        outLocalInsets.right = 0;

        return super.computeSystemWindowInsets(in, outLocalInsets);
    }

    @Override
    protected final boolean fitSystemWindows(@NonNull Rect insets) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            // Intentionally do not modify the bottom inset. For some reason,
            // if the bottom inset is modified, window resizing stops working.
            // TODO: Figure out why.

            mInsets[0] = insets.left;
            mInsets[1] = insets.top;
            mInsets[2] = insets.right;

            insets.left = 0;
            insets.top = 0;
            insets.right = 0;
        }

        return super.fitSystemWindows(insets);
    }
}

Este é o meu layout de fragmento.

<com.dhna.widget.ZeroInsetsFrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    android:background="@color/white">

    <!-- your xml code -->

</ZeroInsetsFrameLayout>

Eu quero que seja útil para você. boa sorte!


É preciso tempo para ocultar e mostrar o teclado e também leva tempo para aumentar o layout. Qualquer solução ? Como gerenciar ?
Vanjara Sweta 26/07/19

0
  • Depois de pesquisar em todos os fóruns. Essas maneiras não podem ajudar a descobrir. Sorte quando tentei fazer isso. Isso me ajuda a resolver o problema

XML

<RelativeLayout 
      xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:fitsSystemWindows="true">
       <!-- Your xml -->
    </RelativeLayout>

Atividade

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView("Your Activity");
   setAdjustScreen();

}

Func criado

protected void setAdjustScreen(){
        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
        getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
        /*android:windowSoftInputMode="adjustPan|adjustResize"*/
}

Por fim, adicionando algumas linhas ao seu mainifest

 <activity
     android:name="Your Activity"
     android:windowSoftInputMode="adjustPan|adjustResize"
     android:screenOrientation="portrait"></activity>

0

Eu tive o mesmo problema. Eu resolvi usando o coordenatorlayout

activity.main.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
    android:layout_height="match_parent" android:layout_width="match_parent"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:android="http://schemas.android.com/apk/res/android">


    <android.support.design.widget.AppBarLayout
    android:layout_height="wrap_content"
    android:layout_width="match_parent"
    android:theme="@style/AppTheme.AppBarOverlay">

    <android.support.v7.widget.Toolbar
        android:layout_height="?attr/actionBarSize"
        android:layout_width="match_parent"
        app:popupTheme="@style/AppTheme.PopupOverlay"
        android:background="?attr/colorPrimary"
        android:id="@+id/toolbar"/>

</android.support.design.widget.AppBarLayout>

    <include layout="@layout/content_main2"/>

</android.support.design.widget.CoordinatorLayout>

content_main2.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:app="http://schemas.android.com/apk/res-auto">


    <android.support.v7.widget.RecyclerView
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:layout_marginTop="30dp"
        android:layout_marginBottom="30dp"
        app:layout_scrollFlags="scroll|exitUntilCollapsed"
        android:id="@+id/post_msg_recyclerview">
    </android.support.v7.widget.RecyclerView>

    <EditText
        android:layout_width="match_parent"
        android:layout_height="50dp"
        app:layout_constraintBottom_toBottomOf="parent"
        android:background="@color/colorPrimary"


        />

</android.support.constraint.ConstraintLayout>

MainActivity.java

agora adicione esta linha linearLayoutManager.setStackFromEnd (true);

 LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
        linearLayoutManager.setStackFromEnd(true);
        recyclerView.setLayoutManager(linearLayoutManager);
        Adapter adapter1=new Adapter(arrayList);
        recyclerView.setAdapter(adapter1);

0
<androidx.constraintlayout.widget.ConstraintLayout
  android:fitsSystemWindows="true">

  <androidx.coordinatorlayout.widget.CoordinatorLayout>
    <com.google.android.material.appbar.AppBarLayout>

      <com.google.android.material.appbar.CollapsingToolbarLayout/>

    </com.google.android.material.appbar.AppBarLayout>

    <androidx.core.widget.NestedScrollView>
    <Editext/>
    <androidx.core.widget.NestedScrollView/>

  </androidx.coordinatorlayout.widget.CoordinatorLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

0

Adicione isso primeiro no seu layout raiz.

android:fitsSystemWindows="true"

Quando você usa essa abordagem, é de sua responsabilidade garantir que partes críticas da interface do usuário do seu aplicativo (por exemplo, os controles internos de um aplicativo Maps) não acabem sendo cobertas pelas barras do sistema. Isso pode tornar seu aplicativo inutilizável. Na maioria dos casos, você pode lidar com isso adicionando o atributo android: fitsSystemWindows ao seu arquivo de layout XML, definido como true. Isso ajusta o preenchimento do ViewGroup pai para deixar espaço para as janelas do sistema. Isso é suficiente para a maioria dos aplicativos.

Em alguns casos, no entanto, pode ser necessário modificar o preenchimento padrão para obter o layout desejado para o seu aplicativo. Para manipular diretamente como o conteúdo é apresentado em relação às barras do sistema (que ocupam um espaço conhecido como "inserções de conteúdo" da janela), substitua fitSystemWindows (inserções Rect). O método fitSystemWindows () é chamado pela hierarquia de exibição quando as inserções de conteúdo de uma janela são alteradas, para permitir que a janela ajuste seu conteúdo de acordo. Ao substituir esse método, você pode manipular as inserções (e, portanto, o layout do seu aplicativo) da maneira que desejar.

https://developer.android.com/training/system-ui/status#behind

Se você deseja se tornar um instalador da janela principal, assista ao vídeo do desenvolvedor do Android. https://www.youtube.com/watch?v=_mGDMVRO3iE


-1

A melhor prática permite o conteúdo de rolagem do usuário quando o teclado é mostrado. Então, para adicionar essa funcionalidade, você precisa colocar seu layout raiz dentro do ScrollViewe usarwindowSoftInputMode="adjustResize" método activity.

Mas se você quiser usar essa funcionalidade com <item name="android:windowTranslucentStatus">true</item> sinalizador no Android 5, o conteúdo não será rolável e se sobrepõe ao teclado.

Para resolver este problema, verifique esta resposta

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.