import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
public void initLog() {
    LogUtils.Config config = LogUtils.getConfig()
            .setLogSwitch(BuildConfig.DEBUG)// 设置log总开关，包括输出到控制台和文件，默认开
            .setConsoleSwitch(BuildConfig.DEBUG)// 设置是否输出到控制台开关，默认开
            .setGlobalTag(null)// 设置log全局标签，默认为空
            // 当全局标签不为空时，我们输出的log全部为该tag，
            // 为空时，如果传入的tag为空那就显示类名，否则显示tag
            .setLogHeadSwitch(true)// 设置log头信息开关，默认为开
            .setLog2FileSwitch(false)// 打印log时是否存到文件的开关，默认关
            .setDir("")// 当自定义路径为空时，写入应用的/cache/log/目录中
            .setFilePrefix("")// 当文件前缀为空时，默认为"util"，即写入文件为"util-MM-dd.txt"
            .setBorderSwitch(true)// 输出日志是否带边框开关，默认开
            .setConsoleFilter(LogUtils.V)// log的控制台过滤器，和logcat过滤器同理，默认Verbose
            .setFileFilter(LogUtils.V)// log文件过滤器，和logcat过滤器同理，默认Verbose
            .setStackDeep(1);// log栈深度，默认为1
    LogUtils.d(config.toString());
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
private void initAssets() {
    if (!FileUtils.isFileExists(Config.TEST_APK_PATH)) {
        ThreadPoolUtils poolUtils = new ThreadPoolUtils(ThreadPoolUtils.SingleThread, 1);
        poolUtils.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    FileIOUtils.writeFileFromIS(Config.TEST_APK_PATH, getAssets().open("test_install"), false);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    } else {
        LogUtils.d("test apk existed.");
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public void onError(@NonNull Throwable e) {
    LoadingDialog.dissmiss();
    String errMsg = "";
    if (e instanceof SocketTimeoutException) {
        errMsg = "网络连接超时，请检查您的网络状态，稍后重试";
    } else if (e instanceof ConnectException) {
        errMsg = "网络连接异常，请检查您的网络状态";
    } else if (e instanceof UnknownHostException) {
        errMsg = "网络异常，请检查您的网络状态";
    } else {
        errMsg = e.getMessage();
    }
    LogUtils.i("onError:" + errMsg);
    _onError(errMsg);

}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
/**
 * 开始解析发送参数
 */
private void sendLogRequest(Request request) throws IOException {
    if (request != null) {
        String body = "";
        if (request.body() != null) {
            Buffer buffer = new Buffer();
            request.body().writeTo(buffer);
            //编码设为UTF-8
            Charset charset = Charset.forName("UTF-8");
            MediaType contentType = request.body().contentType();
            if (contentType != null) {
                charset = contentType.charset(Charset.forName("UTF-8"));
            }
            body = buffer.readString(charset);
            //如果你出现中文参数乱码情况，请进行URL解码处理！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
            body = URLEncoder.encode(body, "UTF-8");
        }
        LogUtils.i("发送----" + "method:" + request.method() + "  url:" + request.url() + "  body:" + body);
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
/**
 * 开始解析服务器返回参数
 */
private void sendLogResponse(Response response) throws IOException {
    String rBody = "";
    if (response != null && response.body() != null) {
        BufferedSource source = response.body().source();
        source.request(Long.MAX_VALUE); // Buffer the entire body.
        Buffer buffer = source.buffer();

        Charset charset = Charset.forName("UTF-8");
        MediaType contentType = response.body().contentType();
        if (contentType != null) {
            try {
                charset = contentType.charset(Charset.forName("UTF-8"));
            } catch (UnsupportedCharsetException e) {
                e.printStackTrace();
            }
        }
        rBody = buffer.clone().readString(charset);
    }
    LogUtils.i("接收：" + rBody.toString());
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public void onClick(View v) {
    new AlertDialog.Builder(fragment.getActivity()).setItems(itemsName, new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            if (which == 0) {
                TopicsDiscount.Item item = items.get(getLayoutPosition());
                Uri uri = Parse.parsePSNStoreUrl(item.getStoreURL(), item.getRegion());
                LogUtils.d(uri);
                Intent intent = new Intent(Intent.ACTION_VIEW, uri);
                ActivityUtils.startActivity(intent);
            } else if (which == 1) {
                Bundle bundle = new Bundle();
                bundle.putString("url", items.get(getLayoutPosition()).getActivityURL());
                ActivityUtils.startActivity(bundle, TopicActivity.class);
            }
        }
    }).show();
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public void getData() {
    swipeRefreshLayout.setRefreshing(true);
    if (url.contains("gif") && !url.contains("large")) {
        url = Parse.parseImageUrl(url, 0);
    }
    list.clear();
    list.add(getString(R.string.save));
    if (!url.contains("large")) {
        list.add(getString(R.string.view_original_image));
    }
    alertDialog = new AlertDialog.Builder(this)
            .setTitle(R.string.option)
            .setItems(list.toArray(new String[list.size()]), this).create();
    LogUtils.d("Load image: " + url);
    if (url.contains("gif")) {
        Glide.with(this).asGif().load(url).into(new ImageViewTarget<GifDrawable>());
    } else {
        Glide.with(this).load(url).into(new ImageViewTarget<>());
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public ObservableSource<T> apply(@NonNull Observable<BaseHttpResult<T>> upstream) {
    return upstream.map(new Function<BaseHttpResult<T>, T>() {
        @Override
        public T apply(@NonNull BaseHttpResult<T> tBaseHttpResult) throws Exception {
            if (tBaseHttpResult == null) {
                throw new ServerException(ErrorType.EMPTY_BEAN, "解析对象为空");
            }
            LogUtils.e(TAG, tBaseHttpResult.toString());
            if (tBaseHttpResult.getStatus() != ErrorType.SUCCESS) {
                throw new ServerException(tBaseHttpResult.getStatus(),
                        tBaseHttpResult.getMessage());
            }
            return tBaseHttpResult.getData();
        }
    }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends T>>() {
        @Override
        public ObservableSource<? extends T> apply(@NonNull Throwable throwable)
                throws Exception {
            // ExceptionEngine 为处理异常的驱动器 throwable
            throwable.printStackTrace();
            return Observable.error(ExceptionEngine.handleException(throwable));
        }
    });

}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
protected void onPostExecute (Throwable param) {
    getRootActivity().showProgress(false, null);
    if (param != null) {
        LogUtils.e(TAG, param);
        if (BuildConfig.DEBUG) param.printStackTrace();
        getRootActivity().setTextColor(Color.RED);
        getRootActivity().setText(getString(R.string.workspace_init_error));
        return;
    }
    if (screen == null || !hasXml) {
        getRootActivity().setTextColor(Color.BLACK);
        getRootActivity().setText(getString(R.string.empty));
    } else {
        setPreferenceScreen(screen);
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
public void initLog() {
    LogUtils.Config config = LogUtils.getConfig()
            .setLogSwitch(BuildConfig.DEBUG)// 设置 log 总开关，包括输出到控制台和文件，默认开
            .setConsoleSwitch(BuildConfig.DEBUG)// 设置是否输出到控制台开关，默认开
            .setGlobalTag(null)// 设置 log 全局标签，默认为空
            // 当全局标签不为空时，我们输出的 log 全部为该 tag，
            // 为空时，如果传入的 tag 为空那就显示类名，否则显示 tag
            .setLogHeadSwitch(true)// 设置 log 头信息开关，默认为开
            .setLog2FileSwitch(false)// 打印 log 时是否存到文件的开关，默认关
            .setDir("")// 当自定义路径为空时，写入应用的/cache/log/目录中
            .setFilePrefix("")// 当文件前缀为空时，默认为"util"，即写入文件为"util-MM-dd.txt"
            .setBorderSwitch(true)// 输出日志是否带边框开关，默认开
            .setConsoleFilter(LogUtils.V)// log 的控制台过滤器，和 logcat 过滤器同理，默认 Verbose
            .setFileFilter(LogUtils.V)// log 文件过滤器，和 logcat 过滤器同理，默认 Verbose
            .setStackDeep(1);// log 栈深度，默认为 1
    LogUtils.d(config.toString());
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
protected void onStart() {
    super.onStart();
    // 注册普通广播
    mReceiver1 = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String str = intent.getStringExtra("name");
            LogUtils.i("onReceive(普通广播，动态注册): " + str);
        }
    };
    IntentFilter filter1 = new IntentFilter();
    filter1.addAction("com.sdwfqin.broadcastdemo");
    registerReceiver(mReceiver1, filter1);

    // ===================================================
    // 注册本地广播
    mReceiver2 = new LocalBroadcastReceiver();
    IntentFilter filter2 = new IntentFilter();
    filter2.addAction("com.sdwfqin.broadcastdemo3");
    LocalBroadcastManager.getInstance(BroadcastActivity.this).registerReceiver(mReceiver2, filter2);
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
private void draw() {
    try {
        // 获取Canvas对象
        mCanvas = mHolder.lockCanvas();
        // SurfaceView背景
        mCanvas.drawColor(Color.WHITE);
        mCanvas.drawPath(mPath, mPaint);
    } catch (Exception e) {
        LogUtils.e("draw: ", e);
    } finally {
        if (mCanvas != null) {
            // 提交画布内容
            mHolder.unlockCanvasAndPost(mCanvas);
        }
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public void run() {
    long start = System.currentTimeMillis();
    while (mIsDrawing) {
        draw();
    }
    long end = System.currentTimeMillis();
    // 50-100
    if (end - start < 100) {
        try {
            Thread.sleep(100 - (end - start));
        } catch (InterruptedException e) {
            LogUtils.i("run: ", e);
        }
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
private void draw() {
    try {
        // 获取Canvas对象
        mCanvas = mHolder.lockCanvas();
        // SurfaceView背景
        mCanvas.drawColor(Color.WHITE);
        mCanvas.drawPath(mPath, mPaint);
    } catch (Exception e) {
        LogUtils.i("draw: ", e);
    } finally {
        if (mCanvas != null) {
            // 提交画布内容
            mHolder.unlockCanvasAndPost(mCanvas);
        }
    }
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
    protected void onDraw(Canvas canvas) {
        LogUtils.i("onDraw: ");
        //不删除的画会默认绘制输入的文字
//        super.onDraw(canvas);

        switch (psdType) {
            case psdType_weChat:
                drawWeChatBorder(canvas);
                break;
            case psdType_bottomLine:
                drawBottomBorder(canvas);
                break;
            default:
                break;
        }

        drawPsdCircle(canvas);
    }
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
/**
 * 监听文本变化
 *
 * @param text
 * @param start
 * @param lengthBefore
 * @param lengthAfter
 */
@Override
protected void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) {
    super.onTextChanged(text, start, lengthBefore, lengthAfter);
    LogUtils.i("onTextChanged: ");
    textLength = text.toString().length();

    // 如果密码输入完成，调用回调方法
    if (mComparePassword != null && textLength == maxCount) {
        if (TextUtils.equals(mComparePassword, getPasswordString())) {
            mListener.onSuccess(getPasswordString());
        } else {
            mListener.onError();
        }
    }
    // 重绘
    invalidate();
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
private void rxJavaFlatMap() {
    Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }).flatMap(integer -> {
        final List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("I am value " + integer);
        }
        // 10毫秒的延时
        return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(s -> LogUtils.e(s));
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
@Override
public void run() {
    LogUtils.v("verbose");
    LogUtils.d("debug");
    LogUtils.i("info");
    LogUtils.w("warn");
    LogUtils.e("初始化成功");
    LogUtils.a("assert");
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
private boolean isKeyboardShown(View rootView) {
    final int softKeyboardHeight = 100;
    Rect frame = new Rect();
    rootView.getWindowVisibleDisplayFrame(frame);
    DisplayMetrics dm = rootView.getResources().getDisplayMetrics();
    int heightDiff = rootView.getBottom() - frame.bottom;
    LogUtils.d("" + rootView.getBottom() + ", " + frame.bottom + ", " + heightDiff);
    return heightDiff > softKeyboardHeight * dm.density;
}
 

import com.blankj.utilcode.util.LogUtils; //导入依赖的package包/类
public static void initLog() {
    LogUtils.Builder builder = new LogUtils.Builder()
            .setLogSwitch(BuildConfig.DEBUG)// 设置log总开关，包括输出到控制台和文件，默认开
            .setConsoleSwitch(BuildConfig.DEBUG)// 设置是否输出到控制台开关，默认开
            .setGlobalTag(null)// 设置log全局标签，默认为空
            // 当全局标签不为空时，我们输出的log全部为该tag，
            // 为空时，如果传入的tag为空那就显示类名，否则显示tag
            .setLogHeadSwitch(true)// 设置log头信息开关，默认为开
            .setLog2FileSwitch(false)// 打印log时是否存到文件的开关，默认关
            .setDir("")// 当自定义路径为空时，写入应用的/cache/log/目录中
            .setBorderSwitch(true)// 输出日志是否带边框开关，默认开
            .setConsoleFilter(LogUtils.V)// log的控制台过滤器，和logcat过滤器同理，默认Verbose
            .setFileFilter(LogUtils.V);// log文件过滤器，和logcat过滤器同理，默认Verbose
    LogUtils.d(builder.toString());
}