Android 如何在没有ActionBar的情况下使用NavigationView创建抽屉布局？

我已经用

NavigationView

创建了

DrawerLayout

但我想要以下类型的布局

我试图在

工具栏中为背景设置透明颜色，但没有成功

如何为打开
抽屉布局
创建唯一的
按钮

我在项目中使用了这个很棒的工具.java文件。它有很多功能，可以轻松完成一些任务。您可以在以后的任何项目中重用它。它还具有使工具栏透明的功能。试试把它放到` package meat.mountedwings.org.utils

import android.app.Activity;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.annotation.ColorInt;
import android.support.annotation.ColorRes;
import android.support.annotation.DrawableRes;
import android.support.v4.content.ContextCompat;
import android.support.v4.graphics.drawable.RoundedBitmapDrawable;
import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory;
import android.support.v4.widget.NestedScrollView;
import android.support.v7.widget.Toolbar;
import android.util.TypedValue;
import android.view.Menu;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.Toast;

import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.target.BitmapImageViewTarget;
import com.google.android.gms.maps.GoogleMap;

// change this to that for your package
import project.your_package_name.org.R;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Tools {

    public static void setSystemBarColor(Activity act) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Window window = act.getWindow();
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            window.setStatusBarColor(act.getResources().getColor(R.color.colorPrimaryDark));
        }
    }

    public static void setSystemBarColor(Activity act, @ColorRes int color) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Window window = act.getWindow();
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            window.setStatusBarColor(act.getResources().getColor(color));
        }
    }

    public static void setSystemBarLight(Activity act) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            View view = act.findViewById(android.R.id.content);
            int flags = view.getSystemUiVisibility();
            flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
            view.setSystemUiVisibility(flags);
        }
    }

    public static void clearSystemBarLight(Activity act) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            Window window = act.getWindow();
            window.setStatusBarColor(ContextCompat.getColor(act, R.color.colorPrimaryDark));
        }
    }

    /**
     * Making notification bar transparent
     */
    public static void setSystemBarTransparent(Activity act) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            Window window = act.getWindow();
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            window.setStatusBarColor(Color.argb(255, 255, 234, 187));
        }
    }

    public static void displayImageOriginal(Context ctx, ImageView img, @DrawableRes int drawable) {
        try {
            Glide.with(ctx).load(drawable)
                    .crossFade()
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .into(img);
        } catch (Exception e) {
        }
    }

    public static void displayImageRound(final Context ctx, final ImageView img, @DrawableRes int drawable) {
        try {
            Glide.with(ctx).load(drawable).asBitmap().centerCrop().into(new BitmapImageViewTarget(img) {
                @Override
                protected void setResource(Bitmap resource) {
                    RoundedBitmapDrawable circularBitmapDrawable = RoundedBitmapDrawableFactory.create(ctx.getResources(), resource);
                    circularBitmapDrawable.setCircular(true);
                    img.setImageDrawable(circularBitmapDrawable);
                }
            });
        } catch (Exception e) {
        }
    }

    public static void displayImageOriginal(Context ctx, ImageView img, String url) {
        try {
            Glide.with(ctx).load(url)
                    .crossFade()
                    .diskCacheStrategy(DiskCacheStrategy.NONE)
                    .into(img);
        } catch (Exception e) {
        }
    }

    public static String getFormattedDateSimple(Long dateTime) {
        SimpleDateFormat newFormat = new SimpleDateFormat("MMMM dd, yyyy");
        return newFormat.format(new Date(dateTime));
    }

    public static String getFormattedDateEvent(Long dateTime) {
        SimpleDateFormat newFormat = new SimpleDateFormat("EEE, MMM dd yyyy");
        return newFormat.format(new Date(dateTime));
    }

    public static String getFormattedTimeEvent(Long time) {
        SimpleDateFormat newFormat = new SimpleDateFormat("h:mm a");
        return newFormat.format(new Date(time));
    }

    public static String getEmailFromName(String name) {
        if (name != null && !name.equals("")) {
            String email = name.replaceAll(" ", ".").toLowerCase().concat("@mail.com");
            return email;
        }
        return name;
    }

    public static int dpToPx(Context c, int dp) {
        Resources r = c.getResources();
        return Math.round(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, r.getDisplayMetrics()));
    }

    public static GoogleMap configActivityMaps(GoogleMap googleMap) {
        // set map type
        googleMap.setMapType(GoogleMap.MAP_TYPE_NORMAL);
        // Enable / Disable zooming controls
        googleMap.getUiSettings().setZoomControlsEnabled(false);

        // Enable / Disable Compass icon
        googleMap.getUiSettings().setCompassEnabled(true);
        // Enable / Disable Rotate gesture
        googleMap.getUiSettings().setRotateGesturesEnabled(true);
        // Enable / Disable zooming functionality
        googleMap.getUiSettings().setZoomGesturesEnabled(true);

        googleMap.getUiSettings().setScrollGesturesEnabled(true);
        googleMap.getUiSettings().setMapToolbarEnabled(true);

        return googleMap;
    }

    public static void copyToClipboard(Context context, String data) {
        ClipboardManager clipboard = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
        ClipData clip = ClipData.newPlainText("clipboard", data);
        clipboard.setPrimaryClip(clip);
        Toast.makeText(context, "Text copied to clipboard", Toast.LENGTH_SHORT).show();
    }

    public static void nestedScrollTo(final NestedScrollView nested, final View targetView) {
        nested.post(new Runnable() {
            @Override
            public void run() {
                nested.scrollTo(500, targetView.getBottom());
            }
        });
    }

    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }

    public static boolean toggleArrow(View view) {
        if (view.getRotation() == 0) {
            view.animate().setDuration(200).rotation(180);
            return true;
        } else {
            view.animate().setDuration(200).rotation(0);
            return false;
        }
    }

    public static boolean toggleArrow(boolean show, View view) {
        return toggleArrow(show, view, true);
    }

    public static boolean toggleArrow(boolean show, View view, boolean delay) {
        if (show) {
            view.animate().setDuration(delay ? 200 : 0).rotation(180);
            return true;
        } else {
            view.animate().setDuration(delay ? 200 : 0).rotation(0);
            return false;
        }
    }

    public static void changeNavigateionIconColor(Toolbar toolbar, @ColorInt int color) {
        Drawable drawable = toolbar.getNavigationIcon();
        drawable.mutate();
        drawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP);
    }

    public static void changeMenuIconColor(Menu menu, @ColorInt int color) {
        for (int i = 0; i < menu.size(); i++) {
            Drawable drawable = menu.getItem(i).getIcon();
            if (drawable == null) continue;
            drawable.mutate();
            drawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP);
        }
    }

    public static void changeOverflowMenuIconColor(Toolbar toolbar, @ColorInt int color) {
        try {
            Drawable drawable = toolbar.getOverflowIcon();
            drawable.mutate();
            drawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP);
        } catch (Exception e) {
        }
    }

    public static int getScreenWidth() {
        return Resources.getSystem().getDisplayMetrics().widthPixels;
    }

    public static int getScreenHeight() {
        return Resources.getSystem().getDisplayMetrics().heightPixels;
    }

    public static String toCamelCase(String input) {
        input = input.toLowerCase();
        StringBuilder titleCase = new StringBuilder();
        boolean nextTitleCase = true;

        for (char c : input.toCharArray()) {
            if (Character.isSpaceChar(c)) {
                nextTitleCase = true;
            } else if (nextTitleCase) {
                c = Character.toTitleCase(c);
                nextTitleCase = false;
            }

            titleCase.append(c);
        }

        return titleCase.toString();
    }

    public static String insertPeriodically(String text, String insert, int period) {
        StringBuilder builder = new StringBuilder(text.length() + insert.length() * (text.length() / period) + 1);
        int index = 0;
        String prefix = "";
        while (index < text.length()) {
            builder.append(prefix);
            prefix = insert;
            builder.append(text.substring(index, Math.min(index + period, text.length())));
            index += period;
        }
        return builder.toString();
    }

}
`

导入android.app.Activity；
导入android.content.ClipData；
导入android.content.ClipboardManager；
导入android.content.Context；
导入android.content.res.Resources；
导入android.graphics.Bitmap；
导入android.graphics.Color；
导入android.graphics.PorterDuff；
导入android.graphics.drawable.drawable；
导入android.os.Build；
导入android.support.annotation.ColorInt；
导入android.support.annotation.ColorRes；
导入android.support.annotation.DrawableRes；
导入android.support.v4.content.ContextCompat；
导入android.support.v4.graphics.drawable.RoundedBitmapDrawable；
导入android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory；
导入android.support.v4.widget.NestedScrollView；
导入android.support.v7.widget.Toolbar；
导入android.util.TypedValue；
导入android.view.Menu；
导入android.view.view；
导入android.view.Window；
导入android.view.WindowManager；
导入android.widget.ImageView；
导入android.widget.Toast；
导入com.bumptech.glide.glide；
导入com.bumptech.glide.load.engine.DiskCacheStrategy；
导入com.bumptech.glide.request.target.BitmapImageViewTarget；
导入com.google.android.gms.maps.GoogleMap；
//为你的包裹把这个换成那个
导入project.your_package_name.org.R；
导入java.text.simpleDataFormat；
导入java.util.Date；
公共类工具{
公共静态无效颜色（活动法）{
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.LOLLIPOP）{
Window Window=act.getWindow（）；
添加标志（WindowManager.LayoutParams.FLAG\u绘图\u系统\u栏\u背景）；
window.clearFlags（WindowManager.LayoutParams.FLAG\u半透明\u状态）；
setStatusBarColor（act.getResources（）.getColor（R.color.colorPrimaryDark））；
}
}
公共静态无效设置颜色（活动法，@ColorRes int-color）{
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.LOLLIPOP）{
Window Window=act.getWindow（）；
添加标志（WindowManager.LayoutParams.FLAG\u绘图\u系统\u栏\u背景）；
window.clearFlags（WindowManager.LayoutParams.FLAG\u半透明\u状态）；
setStatusBarColor（act.getResources（）.getColor（color））；
}
}
公共静态无效指示灯（活动法）{
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.M）{
View=act.findviewbyd（android.R.id.content）；
int flags=view.getSystemUiVisibility（）；
flags |=View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR；
视图.设置系统兼容性（标志）；
}
}
公共静态无效指示灯（活动法）{
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.M）{
Window Window=act.getWindow（）；
setStatusBarColor（ContextCompat.getColor（act，R.color.colorPrimaryDark））；
}
}
/**
*使通知栏透明
*/
公共静态无效设置透明（活动法）{
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.LOLLIPOP）{
Window Window=act.getWindow（）；
添加标志（WindowManager.LayoutParams.FLAG\u绘图\u系统\u栏\u背景）；
setStatusBarColor（Color.argb（255、255、234、187））；
}
}
公共静态无效显示ImageOriginal（上下文ctx、ImageView img、@DrawableRes int drawable）{
试一试{
带（ctx）的滑动载荷（可牵引）
.crossFade（）
.diskCacheStrategy（diskCacheStrategy.NONE）
.into（img）；
}捕获（例外e）{
}
}
公共静态void displayImageRound（最终上下文ctx，最终图像视图img，@DrawableRes int drawable）{
试一试{
使用（ctx）.Glide.with（ctx）.load（drawable）.asBitmap（）.centerCrop（）加载到（新的BitmapImageViewTarget（img））中{
@凌驾
受保护的无效集合资源（位图资源）{
RoundedBitmapDrawable circularBitmapDrawable=RoundedBitmapDrawableFactory.create（ctx.getResources（），resource）；
circularBitmapDrawable.setCircular（true）；
img.setImageDrawable（可循环绘制）；
}
});
}捕获（例外e）{
}
}
公共静态void displayImageOriginal（上下文ctx、ImageView img、字符串url）{
试一试{
Glide.with（ctx.load）（url）
.crossFade（）
.diskCacheStrategy（diskCacheStrategy.NONE）
.into（img）；
}捕获（例外e）{
}
}
公共静态字符串getFormattedDateSimple（长日期时间）{
SimpleDataFormat newFormat=新SimpleDataFormat（“MMMM dd，yyyy”）；
返回newFormat.format（newdate（dateTime））；
}
公共静态字符串getFormattedDateEvent（长日期时间）{
SimpleDataFormat newFormat=新SimpleDataFormat（“EEE，MMM dd yyyy”）；
返回newFormat.format（newdate（dateTime））；
}
公共静态字符串getFormattedTimeEvent（长时间）{
SimpleDataFormat newFormat=新SimpleDataFormat（“h:mm a”）；
返回newFormat.format（新日期（时间））；
}
公共静态字符串getEmailFromName（字符串名称）{
if（name！=null&&！name.equals（“”）{
Str