bcoder

communication to xxx.com not permitted by network security policy错误的原因

分类：Android, Java 阅读 (2,376) 已关闭评论

11月 182019

这是因为Android P(9.0)限制了http的明文请求的原因，具体分析见下面转发的文章

转发：

在Android P(9.0) 系统中，限制了明文流量的网络请求，因为安卓新版本默认是不允许使用明文网络传输的，会强制让应用都使用https，非加密的流量请求都会被系统禁止掉。

Google表示，为保证用户数据和设备的安全，针对下一代Android系统（Android P）的应用程序，将要默认使用加密连接，这意味着Android P将禁止APP使用所有未加密的连接，因此运行Android P 系统是安卓无论是接收流量还是发送流量，都不能明文传输，需要使用下一代（Transport Layer Security）传输层安全协议，而Android Nougat和Oreo则不受影响。如果WebView 的url使用http协议，同样会出现加载失败，https则不受影响。

如过在Android P(9.0)上依然使用明文传输，则有下面三种解决方案：

1、将APP改用https请求；

2、将targetSdkVersion降到27以下；

3、在res下新建一个xml目录，然后创建一个名为：network_security_config.xml文件，这是一个系统的网络安全配置文件，该文件内容如下：

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="true" />
</network-security-config>

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

<network-security-config>

<base-config cleartextTrafficPermitted="true" />

</network-security-config>

然后在APP的AndroidManifest.xml文件下的application标签内增加下面一条属性就OK了

<application
...
 android:networkSecurityConfig="@xml/network_security_config"
...
/>

<application

...

android:networkSecurityConfig="@xml/network_security_config"

...

————————————————
版权声明：本文为CSDN博主「时代新人」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u013184970/article/details/88116680

安卓引用资源出现 error: resource android:drawable/…..is private.

分类：Android, Java 阅读 (1,781) 已关闭评论

10月 222019

原文链接：https://blog.csdn.net/qq_40585267/article/details/96284943

从错误信息可以看出，该资源没有被公开是私有的。导致无法被引用。
我们可以直接将“@android”改成“@*android”
问题解决。。。。

adb捕获系统广播的方法

分类：Android, Android, Java, Operating System 阅读 (5,373) 已关闭评论

10月 182019

用于监测最近一段时间内发出的全局广播

adb shell dumpsys activity | grep BroadcastRecord |grep -v android.

grep -v android.意思是不显示包含android.字符的广播

dumpsys显示的广播在１０秒左右就会被清除，所以在广播发送以后短时间内才有效

Android中ndk开发步骤

分类：Android, Java 阅读 (1,129) 已关闭评论

9月 062019

一、环境

Android Studio 3.4.2

c++编译器：cmake

本文从一个不包含c++支持的项目开始添加ndk的开发

二、修改build.gradle

在app/build.gradle中的android节点中增加externalNativeBuild节点，如下：

apply plugin: 'com.android.application'

android {
    compileSdkVersion 28
    buildToolsVersion "29.0.1"
    defaultConfig {
        //...
    }
    buildTypes {

        //....
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }
}

dependencies {
    //....
}

apply plugin: 'com.android.application'

android {

compileSdkVersion 28

buildToolsVersion "29.0.1"

defaultConfig {

//...

}

buildTypes {

//....

}

externalNativeBuild {

cmake {

path "CMakeLists.txt"

}

dependencies {

//....

}

我们指定cmake的配置文件为CMakeLists.txt，其位置应该在app/CMakeLists.txt

二、创建CMakeLists.txt

创建文件app/CMakeLists.txt

三、新建一个java类用于调用c++的函数

因为jni的函数声明必须和具体的类名关联，我们新建一个CUtils类来处理，新建一个CUtils.java

(Ａｎｄｒｏｉｄ默认的例子中都是放在MainActivity中，所以你看到的c中的函数名都是类似这样的Java_com_xxx_xx_MainActivity_func这样的)

假设我们要测试一个实现求和的ｊｎｉ函数，名字叫getSum，先在CUtils.java中定义对native中的引用，CUtils.java代码如下：

package com.zht.car.ndktestapp;

public class CUtils {
    static {
        System.loadLibrary("ndktest");
    }
    
    public static native int getSum(int x, int y);
}

package com.zht.car.ndktestapp;

public class CUtils {

static {

System.loadLibrary("ndktest");

}

public static native int getSum(int x, int y);

}

四、创建c++文件

选择菜单File->New->C/C++ Source File，输入名字test

#include "jni.h"

extern "C"{

JNIEXPORT jint JNICALL Java_com_zht_car_ndktestapp_CUtils_getSum(JNIEnv *env,
    jobject /* this */,
    jint x, jint y){
    return x + y;
}

}

#include "jni.h"

extern "C"{

JNIEXPORT jint JNICALL Java_com_zht_car_ndktestapp_CUtils_getSum(JNIEnv *env,

jobject /* this */,

jint x, jint y){

return x + y;

}

五、编辑CMakeLists.txt

add_library (
    ndktest
    SHARED
    test.cpp
)

add_library (

ndktest

SHARED

test.cpp

)

关于java中移位操作效率测试一例

分类：Java, Java语言阅读 (1,079) 已关闭评论

9月 062019

此场景通常是用在网络通讯中，解决数据头的时候

一般我们会约定头两个字节为某个固定值用于判断是否是有效的数据

如下代码中我们用两种方法做对比，一种是用移位操作将字节头换成int型然后比如

一种是把byte数组中的每一位进行比较

通过比较对比，比较byte数组中的每一位速度会更快。

    public static void main(String[] args){
        byte[] bytes = new byte[]{1, 2, 3, 4};
        long counter = 0;
        long start = System.currentTimeMillis();
        while (true){
            counter++;
            if(counter > 1000000000){
                break;
            }

            int  s = (short) ((bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[1]);
            if(s == 1){
                bytes[0] = 1;
            }
        }

        long end = System.currentTimeMillis();
        System.out.println(bytes[0]);
        System.out.println("转int用时：" + String.valueOf(end - start));

        counter = 0;
        start = System.currentTimeMillis();
        while (true){
            counter++;
            if(counter > 1000000000){
                break;
            }

            if (bytes[0] == 1 && bytes[1] == 1 && bytes[2] == 1 && bytes[3] == 1){
                bytes[0] = 1;
            }
        }

        end = System.currentTimeMillis();
        System.out.println(bytes[0]);
        System.out.println("byte数组每一位比较用时：" + String.valueOf(end - start));
    }

public static void main(String[] args){

byte[] bytes = new byte[]{1, 2, 3, 4};

long counter = 0;

long start = System.currentTimeMillis();

while (true){

counter++;

if(counter > 1000000000){

break;

}

int s = (short) ((bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[1]);

if(s == 1){

bytes[0] = 1;

}

long end = System.currentTimeMillis();

System.out.println(bytes[0]);

System.out.println("转int用时：" + String.valueOf(end - start));

counter = 0;

start = System.currentTimeMillis();

while (true){

counter++;

if(counter > 1000000000){

break;

}

if (bytes[0] == 1 && bytes[1] == 1 && bytes[2] == 1 && bytes[3] == 1){

bytes[0] = 1;

}

end = System.currentTimeMillis();

System.out.println(bytes[0]);

System.out.println("byte数组每一位比较用时：" + String.valueOf(end - start));

}

下面是测试结果：

转int用时：634
byte数组每一位比较用时：299

1 2	转int用时：634 byte数组每一位比较用时：299

NDK 编译报错 SIMPLE: Error configuring

分类：Android, Java 阅读 (1,163) 已关闭评论

9月 052019

开发环境：Ubuntu 16.04+Android Studio 3.4.2

添加c++文件后gradle编译不过去，报SIMPLE: Error configuring错误

解决办法：

安装ninja-build

sudo apt install ninja-build

Java单例模式的几种写法

分类：Java, Java语言, Uncategorized 阅读 (1,041) No Responses »

9月 052019

一、饿汉模式

饿汉模式在声明静态内部对象时就创建该对象，就是不管在程序中是否用到这个静态对象都会创建它，对于不一定会使用该对象的程序是一种资源的浪费，代码如下：

public class SingletonTest {
    private static SingletonTest _singleton = new SingletonTest();

    private SingletonTest() { }

    public static SingletonTest instance(){
        return _singleton;
    }
}

public class SingletonTest {

private static SingletonTest _singleton = new SingletonTest();

private SingletonTest() { }

public static SingletonTest instance(){

return _singleton;

}

因为饿汉模式在声明的时候就创建了，所以不会有线程安全问题

对于构造函数需要传入参数的单例也没办法这样创建

二、懒汉模式

懒汉模式，即在使用的时候才去创建它，相对于饿汉他有点懒，但其实他不懒

代码如下：

public class SingletonTest {
    private static SingletonTest _singleton ;

    private SingletonTest() { }

    public static SingletonTest instance(){
        if(_singleton == null) {
            _singleton = new SingletonTest();
        }
        return _singleton;
    }
}

public class SingletonTest {

private static SingletonTest _singleton ;

private SingletonTest() { }

public static SingletonTest instance(){

if(_singleton == null) {

_singleton = new SingletonTest();

}

return _singleton;

}

假如在多个线程中都会用到这个单例对象，那么就有可能造成实例出多个对象的问题了，就是这种方式是线程不安全的

三、锁方法的懒汉模式（不推荐使用）

我们在instance()方法前加上synchronized修饰，这样多个线程就不可能同时进入instance方法了，也不会造成new多个实例的问题了

代码如下：

public class SingletonTest {
    private static SingletonTest _singleton = null;

    private SingletonTest() { }

    public synchronized static SingletonTest instance(){
        if(_singleton == null) {
            _singleton = new SingletonTest();
        }
        return _singleton;
    }
}

public class SingletonTest {

private static SingletonTest _singleton = null;

private SingletonTest() { }

public synchronized static SingletonTest instance(){

if(_singleton == null) {

_singleton = new SingletonTest();

}

return _singleton;

}

四、局部锁（不可使用）

public class SingletonTest {
    private static SingletonTest _singleton = null;

    private SingletonTest() { }

    public  static SingletonTest instance(){
        if(_singleton == null) {
            synchronized (SingletonTest.class) {
                _singleton = new SingletonTest();
            }
        }
        return _singleton;
    }
}

public class SingletonTest {

private static SingletonTest _singleton = null;

private SingletonTest() { }

public static SingletonTest instance(){

if(_singleton == null) {

synchronized (SingletonTest.class) {

_singleton = new SingletonTest();

}

return _singleton;

}

这种方式看似加了一个锁，但是多个线程可能同时进入到if的判断语句中，同样不能保证_singleton的唯一性

五、双重检查锁+volatile修饰（推荐使用）

代码如下：

public class SingletonTest {
    private volatile static SingletonTest _singleton = null;

    private SingletonTest() { }

    public  static SingletonTest instance(){
        if(_singleton == null) {
            synchronized (SingletonTest.class) {
                if(_singleton == null) {
                    _singleton = new SingletonTest();
                }
            }
        }
        return _singleton;
    }
}

public class SingletonTest {

private volatile static SingletonTest _singleton = null;

private SingletonTest() { }

public static SingletonTest instance(){

if(_singleton == null) {

synchronized (SingletonTest.class) {

if(_singleton == null) {

_singleton = new SingletonTest();

}

return _singleton;

}

树莓派gpio编程（二）声控器输入

分类：C++, Others, Others 阅读 (1,269) 已关闭评论

8月 222019

一、编程语言

使用c语言和wiringPi库

具体见树莓派gpio编程（一）控制Led灯

二、硬件连接

对于这种开关量的传感器，一般有三个针脚VCC、GND、OUT，通常情况下连接方式如下：

vcc接树莓派引脚的3.3v

gnd接树莓派的gnd

out接树莓派gpio0

三、软件编写

新建inputtest.c，并输入以下内容

#include <stdio.h>
#include <wiringPi.h>


#define LED 0
#define BLINK_INTERVAL 100

int main(void){
	printf("LED blink!\n");
	wiringPiSetup();
	pinMode(LED, INPUT);
	for(;;){
		int input = digitalRead(LED);
		printf("input is %d\n", input);
		delay(BLINK_INTERVAL);
	}
	return 0;
}

#include <stdio.h>

#include <wiringPi.h>

#define LED 0

#define BLINK_INTERVAL 100

int main(void){

printf("LED blink!\n");

wiringPiSetup();

pinMode(LED, INPUT);

for(;;){

int input = digitalRead(LED);

printf("input is %d\n", input);

delay(BLINK_INTERVAL);

}

return 0;

}

四、软件编译

使用下面的命令编译程序

gcc inputtest.c -lwiringPi -Wall -o inputtest

1	gcc inputtest.c -lwiringPi -Wall -o inputtest

五、运行程序

在控制台中输入以下命令运行程序

./inputtest

六、运行结果

当发出声音，声控器被触发的时候会输出input is 1

否则输出input is 0

七、其他说明

对于避障器、测速器等开关量的传感器都可以使用此程序读取输入

Java中使用ByteBuffer处理tcp粘包

分类：Android, Java, Java语言阅读 (3,322) 已关闭评论

8月 222019

一、通讯数据格式

通讯协议的约定格式如下：

每一个数据包的长度不固定，但是前四个字节代表的意义是固定的

数据的长度取决于第３个字段的值

名称	长度	其他说明
协议头	2字节	固定的两个字节，用以给协议分段
数据类型	1字节	数据内容的类型，用以区别多种内容
数据长度	1字节	后面数据内容的长度，1字节可表示最大长度是255
数据	n字节	n取决于上一个字节中的数值
…
…
…

二、处理的难点

长度不固定，解析每一组数据时需要先想办法获取数据的长度
如果发送速度很快，收到一包可能有多组数据，需要一个while循环处理收到的一包的数据（这也就是粘包处理的初衷）
收到一包数据（本例中使用1024长度的缓冲区接收）可能将某个数据包截成两截，当前缓冲区未解析完的要保留下来，否则会丢数据

三、处理流程图

四、代码

在while(true)里面是读取tcp数据和进行粘包处理的代码

    class ReceiveThread extends Thread{
        private boolean mReadSucc ;

        private Handler mainThread = new Handler(Looper.getMainLooper());

        @Override
        public void run() {
            super.run();

            int readlen = 0;
            byte[] buffer = new byte[1024];
            ByteBuffer stickyBuffer = ByteBuffer.allocate(4096);
            boolean foundHeader = false;

            while (true){
                if(!mIsServiceRunning){
                    break;
                }

                try {
                    sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                try {
                    mReadSucc = false;
                    readlen = mInputStream.read(buffer);
                    mReadSucc = true;
                } catch (IOException e) {
                    e.printStackTrace();
                }

                if(!mReadSucc || readlen == 0){
                    continue;
                }

                stickyBuffer.limit(4096);
                stickyBuffer.put(buffer, 0, readlen);
                stickyBuffer.flip();

                while (true){
                    if(!stickyBuffer.hasRemaining()){
                        stickyBuffer.compact();
                        stickyBuffer.clear();
                        break;
                    }

                    stickyBuffer.mark();
                    if(stickyBuffer.remaining() < 4){
                        int remaining = stickyBuffer.remaining();
                        stickyBuffer.compact();
                        stickyBuffer.position(remaining);
                        stickyBuffer.limit(remaining);
                        foundHeader = false;
                        break;
                    } else {
                        short magicno = stickyBuffer.getShort();

                        if(magicno != (short) 0xC0DE){
                            continue;
                        } else {
                            foundHeader = true;
                        }
                    }

                    if (foundHeader){
                        int datatype = stickyBuffer.get() & 0xFF;
                        int datalen = stickyBuffer.get() & 0xFF;

                        if(stickyBuffer.remaining() < datalen) {
                            stickyBuffer.reset();
                            stickyBuffer.compact();
                            break;
                        } else {
                            byte[] databuf = new byte[datalen];
                            stickyBuffer.get(databuf);
                            processSerialData(datatype, databuf);
                        }
                    }
                }
            }
        }

class ReceiveThread extends Thread{

private boolean mReadSucc ;

private Handler mainThread = new Handler(Looper.getMainLooper());

@Override

public void run() {

super.run();

int readlen = 0;

byte[] buffer = new byte[1024];

ByteBuffer stickyBuffer = ByteBuffer.allocate(4096);

boolean foundHeader = false;

while (true){

if(!mIsServiceRunning){

break;

}

try {

sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

try {

mReadSucc = false;

readlen = mInputStream.read(buffer);

mReadSucc = true;

} catch (IOException e) {

e.printStackTrace();

}

if(!mReadSucc || readlen == 0){

continue;

}

stickyBuffer.limit(4096);

stickyBuffer.put(buffer, 0, readlen);

stickyBuffer.flip();

while (true){

if(!stickyBuffer.hasRemaining()){

stickyBuffer.compact();

stickyBuffer.clear();

break;

}

stickyBuffer.mark();

if(stickyBuffer.remaining() < 4){

int remaining = stickyBuffer.remaining();

stickyBuffer.compact();

stickyBuffer.position(remaining);

stickyBuffer.limit(remaining);

foundHeader = false;

break;

} else {

short magicno = stickyBuffer.getShort();

if(magicno != (short) 0xC0DE){

continue;

} else {

foundHeader = true;

}

if (foundHeader){

int datatype = stickyBuffer.get() & 0xFF;

int datalen = stickyBuffer.get() & 0xFF;

if(stickyBuffer.remaining() < datalen) {

stickyBuffer.reset();

stickyBuffer.compact();

break;

} else {

byte[] databuf = new byte[datalen];

stickyBuffer.get(databuf);

processSerialData(datatype, databuf);

}

五、其他说明

串口通讯的粘包处理也可以使用此方法

java中的左移<<操作符

分类：Java, Java语言阅读 (1,716) 已关闭评论

8月 162019

对于正数来说，左移１位相当于这个数值翻倍，或者对于类型为int的负数来说，左移一位也是翻倍

但是对于类型小于int的类型，比如short和byte，本来以为左移并不会带符号，但经过测试不是这样的，看代码：

        byte moveb = -3;
        System.out.println("moveb: " + moveb + "   "  + ConvertUtils.byte2binary(moveb));
        int move_L1 = moveb << 1;
        System.out.println("左移1位： " + move_L1 + "   " + ConvertUtils.int2binary(move_L1));
        int move_L8 = moveb << 8;
        System.out.println("左移８位： " + move_L8 + "   " + ConvertUtils.int2binary(move_L8));
        int move_L16 = moveb << 16;
        System.out.println("左移16位： " + move_L16 + "   " + ConvertUtils.int2binary(move_L16));
        int move_L24 = moveb << 24;
        System.out.println("左移24位： " + move_L24 + "   " + ConvertUtils.int2binary(move_L24));

byte moveb = -3;

System.out.println("moveb: " + moveb + " " + ConvertUtils.byte2binary(moveb));

int move_L1 = moveb << 1;

System.out.println("左移1位： " + move_L1 + " " + ConvertUtils.int2binary(move_L1));

int move_L8 = moveb << 8;

System.out.println("左移８位： " + move_L8 + " " + ConvertUtils.int2binary(move_L8));

int move_L16 = moveb << 16;

System.out.println("左移16位： " + move_L16 + " " + ConvertUtils.int2binary(move_L16));

int move_L24 = moveb << 24;

System.out.println("左移24位： " + move_L24 + " " + ConvertUtils.int2binary(move_L24));

左移后为int型数值，本来以左移８位后，前１６位会用０填充，但是没有，左移是带符号移位的，看运行结果如下：

moveb: -3   11111101
左移1位： -6   11111111 11111111 11111111 11111010
左移８位： -768   11111111 11111111 11111101 00000000
左移16位： -196608   11111111 11111101 00000000 00000000
左移24位： -50331648   11111101 00000000 00000000 00000000

moveb: -3 11111101

左移1位： -6 11111111 11111111 11111111 11111010

左移８位： -768 11111111 11111111 11111101 00000000

左移16位： -196608 11111111 11111101 00000000 00000000

左移24位： -50331648 11111101 00000000 00000000 00000000

好，我们再看看其他情况的。

１、byte为正数的情况，moveb = 2的运行结果

moveb: 2   00000010
左移1位： 4   00000000 00000000 00000000 00000100
左移８位： 512   00000000 00000000 00000010 00000000
左移16位： 131072   00000000 00000010 00000000 00000000
左移24位： 33554432   00000010 00000000 00000000 00000000

moveb: 2 00000010

左移1位： 4 00000000 00000000 00000000 00000100

左移８位： 512 00000000 00000000 00000010 00000000

左移16位： 131072 00000000 00000010 00000000 00000000

左移24位： 33554432 00000010 00000000 00000000 00000000

Page 10 of 39 Newer Entries 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 Older Entries