Android/Java





```xml
    
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
    
    <uses-permission
        android:name="android.permission.BLUETOOTH_SCAN"
        android:usesPermissionFlags="neverForLocation"
        tools:targetApi="s" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
```



Andoird蓝牙java：

```cpp
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 请求权限
        requestPermissions();
//        settingBlueTooth();
//        scanLeDevice(true);
        // 初始化蓝牙适配器
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        // 开始搜索蓝牙设备
        if (bluetoothAdapter != null && bluetoothAdapter.isEnabled()) {
            if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            bluetoothAdapter.startDiscovery();
            // 注册广播接收器来接收蓝牙搜索结果
            IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
            bluetoothReceiver = new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    String action = intent.getAction();
                    if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                        // 从Intent中获取蓝牙设备对象
                        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                        // 打印蓝牙设备的MAC地址
                        if (device != null) {
                            Log.i(TAG, "Found device: " + device.getAddress());
                            // 如果设备的MAC A4开头，就是我们的设备
                            if (device.getAddress().startsWith("A4")) {
                                Log.i(TAG, "Found our device: " + device.getAddress());
                            }
                        }
                    }
                }
            };
            registerReceiver(bluetoothReceiver, filter);
        } else {
            Log.e(TAG, "Bluetooth is not available");
        }
        EdgeToEdge.enable(this);
        setContentView(R.layout.activity_main);
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
            return insets;
        });
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止蓝牙设备搜索并注销广播接收器
        if (bluetoothAdapter != null) {
            if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            bluetoothAdapter.cancelDiscovery();
        }
        unregisterReceiver(bluetoothReceiver);
    }
```

请求权限requestPermissions

```cpp
    private void requestPermissions() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
            if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_ADMIN) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED
            ) {
                // 如果没有获取到权限，请求权限
                ActivityCompat.requestPermissions(this, new String[]{
                        android.Manifest.permission.BLUETOOTH,
                        android.Manifest.permission.BLUETOOTH_ADMIN,
                        android.Manifest.permission.ACCESS_FINE_LOCATION,
                        android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
                }, PERMISSION_REQUEST_CODE);
            }
        } else {
            if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_ADVERTISE) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
                    || ContextCompat.checkSelfPermission(this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED
            ) {
                // 如果没有获取到权限，请求权限
                ActivityCompat.requestPermissions(this, new String[]{
                        android.Manifest.permission.BLUETOOTH_SCAN,
                        android.Manifest.permission.BLUETOOTH_ADVERTISE,
                        android.Manifest.permission.BLUETOOTH_CONNECT,
                        android.Manifest.permission.ACCESS_FINE_LOCATION,
                        android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
                }, PERMISSION_REQUEST_CODE);
            }
        }
        // 如果权限已经被授予，直接进行蓝牙功能检查和定位功能检查
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止蓝牙设备搜索并注销广播接收器
        if (bluetoothAdapter != null) {
            if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            bluetoothAdapter.cancelDiscovery();
        }
        unregisterReceiver(bluetoothReceiver);
    }
```



![在这里插入图片描述](/static/img/images/03204.png)

# 问询、帮助

你如果需要帮助，请看这里：

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【Andoird开发】android获取蓝牙权限，搜索蓝牙设备MAC

# 为Android Studio设置proxy





如图所示，注意图中红色的字：

![在这里插入图片描述](/static/img/images/03645.png)


# 其他介绍

在 Android Studio 中，`build.gradle` 是一个非常重要的配置文件，它用于定义项目的构建设置，包括依赖项、插件、任务等。下面是一个简单的教程，帮助你了解如何编写 `build.gradle` 文件：

### 1. 创建项目

首先，打开 Android Studio 并创建一个新的 Android 项目。Android Studio 会自动生成一些默认的文件和目录结构，其中就包括 `build.gradle` 文件。

### 2. 了解两种 `build.gradle` 文件

在 Android 项目中，通常会有两个 `build.gradle` 文件，一个是位于项目根目录下的，另一个是位于每个模块（如app模块）目录下的。

- 项目根目录下的 `build.gradle` 文件主要用于配置整个项目的构建设置，比如项目依赖、全局变量等。

- 模块目录下的 `build.gradle` 文件用于配置该模块的构建设置，比如应用插件、模块依赖等。

### 3. 编写项目根目录下的 `build.gradle` 文件

```gradle
// Top-level build file where you can add configuration options common to all sub-projects/modules.
// 在这里可以添加所有子项目/模块的通用配置选项
// 1. 配置构建脚本的仓库
buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:4.2.2' // Android Gradle 插件版本
    }
}
// 2. 应用插件
plugins {
    id 'com.android.application' // 应用程序插件
}
// 3. 构建脚本的全局配置
android {
    compileSdkVersion 31 // 编译 SDK 版本
    buildToolsVersion "31.0.0" // 构建工具版本
    defaultConfig {
        applicationId "com.example.myapp" // 应用程序包名
        minSdkVersion 21 // 最低支持的 Android 版本
        targetSdkVersion 31 // 目标 Android 版本
        versionCode 1 // 版本号
        versionName "1.0" // 版本名称
    }
}
// 4. 任务定义
task clean(type: Delete) {
    delete rootProject.buildDir
}
```

### 4. 编写模块目录下的 `build.gradle` 文件

```gradle
// 在这里可以添加该模块的特定配置选项
// 1. 模块依赖
dependencies {
    implementation 'androidx.appcompat:appcompat:1.3.1' // 依赖的库
    implementation 'com.google.android.material:material:1.4.0' // Material Design 库
}
// 2. 其他配置
android {
    // 可以覆盖项目根目录中的配置
}
```

### 5. 同步项目

完成以上步骤后，点击 Android Studio 中的 "Sync Now" 按钮，使更改生效。

这只是一个简单的教程，帮助你入门编写 `build.gradle` 文件。实际上，`build.gradle` 文件支持更多的配置选项和语法，你可以根据项目的需求进一步学习和探索。

Android Studio Sync无法构建build.gradle，如何解决网络问题

【每日练手】history：





[【Android】【Java】【每日练手1】字符串的二维码生成器](https://blog.csdn.net/x1131230123/article/details/130745892?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22130745892%22,%22source%22:%22x1131230123%22%7D)

# 需求

基于zxing开发一个android软件，一个按钮打开摄像头，摄像头的内容会显示到手机屏幕，然后以尽可能快的方式调用zxing对每一帧画面进行二维码扫码，如果扫描到了二维码，那就滴一声后跳转到二维码扫描结果界面，这个功能很像微信扫码。

# Activity的跳转

源码：

```java
package com.example.gen_qr_code;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import androidx.annotation.Nullable;
import android.content.Intent;
import android.widget.Button;
import com.google.zxing.integration.android.IntentIntegrator;
import com.google.zxing.integration.android.IntentResult;
public class MainActivity extends AppCompatActivity {
    private Button scanButton;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        scanButton = findViewById(R.id.scanButton);
        scanButton.setOnClickListener(v -> {
            // 打开摄像头并显示预览
            IntentIntegrator integrator = new IntentIntegrator(MainActivity.this);
            integrator.setBeepEnabled(true);
            integrator.setCameraId(0); // 选择摄像头，0为后置摄像头，1为前置摄像头
            integrator.setOrientationLocked(false); // 是否锁定屏幕方向
            integrator.initiateScan();
        });
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        // 处理扫描结果
        IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
        if (result != null) {
            String contents = result.getContents();
            if (contents != null && !contents.isEmpty()) {
                // 扫描成功，可以根据需要进行处理
                Intent intent = new Intent(this, ScanResultActivity.class);
                intent.putExtra("scan_result", contents);
                startActivity(intent);
            }
        }
    }
}
```

在这段代码里，这个IntentIntegrator库在内部开启了新的activity，扫描后结果给到@Nullable Intent data：

```
            // 打开摄像头并显示预览
            IntentIntegrator integrator = new IntentIntegrator(MainActivity.this);
            integrator.setBeepEnabled(true);
            integrator.setCameraId(0); // 选择摄像头，0为后置摄像头，1为前置摄像头
            integrator.setOrientationLocked(false); // 是否锁定屏幕方向
            integrator.initiateScan();
```

onActivityResult是一个回调方法，用于处理在Activity中启动其他Activity并等待返回结果的情况。当启动的Activity结束并返回结果时，系统会调用onActivityResult方法来接收返回的结果数据。

在给定的代码中，onActivityResult方法被重写并添加了自定义的处理逻辑。当调用initiateScan()方法启动扫描界面后，用户完成扫描并返回结果后，系统会调用onActivityResult方法，并将结果数据传递给该方法的参数中（requestCode、resultCode和data）。在该方法内部，通过IntentIntegrator.parseActivityResult方法解析扫描结果，并判断是否成功扫描到内容。如果扫描成功，则将结果数据传递给ScanResultActivity并启动该Activity显示扫描结果。

![在这里插入图片描述](/static/img/images/04553.png)

# 使用Intent在Activity之间传递信息

这段代码是在onActivityResult方法中，用于启动一个新的Activity（ScanResultActivity）来显示扫描结果。

解释如下：

创建一个新的Intent对象：Intent intent = new Intent(this, ScanResultActivity.class);

**Intent是用于在不同组件之间传递数据的对象。这里创建了一个新的Intent对象，用于指定要启动的Activity和传递的数据。**

this表示当前的上下文，即MainActivity。

添加额外的数据到Intent中：intent.putExtra("scan_result", contents);

putExtra方法用于将额外的数据添加到Intent中。这里将扫描结果数据存储在名为"scan_result"的键下。

contents是从扫描结果中获取的具体内容。

启动Activity：startActivity(intent);

startActivity方法用于启动指定的Activity，并传递之前创建的Intent对象作为参数。

这将导致系统启动ScanResultActivity并显示扫描结果。

通过以上代码，当扫描成功并获得内容后，MainActivity会创建一个带有扫描结果数据的Intent，然后使用该Intent启动ScanResultActivity，以便显示扫描结果给用户查看。


```java
                Intent intent = new Intent(this, ScanResultActivity.class);
                intent.putExtra("scan_result", contents);
                startActivity(intent);
```


# @Nullable Intent data

@Nullable是一个注解，用于表示参数可以为空。在这个特定的代码中，@Nullable Intent data表示data参数可以为空。

在onActivityResult方法中，系统会传递扫描结果的数据给data参数。这里使用@Nullable注解是为了明确指出data参数可以为null，以应对在某些情况下没有返回数据的情况（例如用户取消了扫描操作）。

在方法体内部，代码通过使用IntentIntegrator.parseActivityResult方法来解析传递的数据，其中data参数被用来传递扫描结果。在后续的逻辑中，会对data参数进行判断，以确保在有有效的扫描结果时才进行进一步处理。

@Nullable Intent data表示data参数可以为空，用于接收从其他Activity返回的数据，这里用于接收扫描结果的数据。

# startActivity(intent)

在一个Activity里启动另外一个Activity只有startActivity(intent)才可以？不是的。


除了使用startActivity(intent)方法之外，还有其他方法可以启动另一个Activity。以下是一些常用的方法：

**startActivityForResult(intent, requestCode)**: 该方法用于启动一个Activity，并期望获取返回的结果。可以通过requestCode参数指定一个标识码，以便在返回结果时进行区分。在目标Activity中通过setResult(resultCode, data)方法设置返回结果，并通过finish()方法关闭目标Activity，然后在调用该方法的Activity中的onActivityResult()方法中获取返回的结果。

**startActivityIfNeeded(intent)**: 该方法用于启动一个Activity，但只有在目标Activity不在前台时才会启动。如果目标Activity已经在前台运行，那么不会重新创建一个新的实例。

**startActivityFromChild(child, intent, requestCode)**: 该方法用于在一个父Activity中启动子Activity。child参数指定要启动子Activity的子视图，requestCode参数用于获取返回结果。

**startActivityFromFragment(fragment, intent, requestCode)**: 该方法用于在一个Fragment中启动一个Activity。fragment参数指定要启动Activity的Fragment，requestCode参数用于获取返回结果。

这些方法提供了不同的灵活性和用途，根据你的需求选择适合的方法来启动另一个Activity。

# 获取Intent数据

String scanResult = getIntent().getStringExtra("scan_result")
```java
package com.example.gen_qr_code;
import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
public class ScanResultActivity  extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_scan_result);
        TextView resultTextView = findViewById(R.id.resultTextView);
        String scanResult = getIntent().getStringExtra("scan_result");
        resultTextView.setText(scanResult);
        TextView result_title = findViewById(R.id.result_title);
        result_title.setText("扫描结果：");
    }
}
```

# github

[https://github.com/xxddccaa/android_scan_qrcode](https://github.com/xxddccaa/android_scan_qrcode)

【Android】【Java】【每日练手2】基于zxing的扫码与扫码结果跳转

# 一、需求





一个界面，界面上一个文本输入框、一个按钮、一个二维码显示view。可在文本输入框输入字符串，点击按钮后，生成二维码。


# 二、创建android stdio工程

![在这里插入图片描述](/static/img/images/04559.png)

![在这里插入图片描述](/static/img/images/04560.png)

# 三、设置好JDK

![在这里插入图片描述](/static/img/images/04561.png)

![在这里插入图片描述](/static/img/images/04562.png)

我开始使用JDK 11：

![在这里插入图片描述](/static/img/images/04563.png)

# 四、创建activity

![在这里插入图片描述](/static/img/images/04564.png)

得到：

![在这里插入图片描述](/static/img/images/04565.png)

# 五、编写activity_main.xml布局

```xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="50dp"
        android:hint="请输入要生成二维码的字符串" />
    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="生成二维码" />
    <ImageView
        android:id="@+id/imageView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</LinearLayout>
```

# 六、build.gradle增加zxing依赖

![在这里插入图片描述](/static/img/images/04566.png)

# 七、MainActivity 

```java
package com.example.gen_qr_code;
import androidx.appcompat.app.AppCompatActivity;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.EditText;
import android.widget.ImageView;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.QRCodeWriter;
import java.nio.charset.StandardCharsets;
public class MainActivity extends AppCompatActivity {
    private EditText editText;
    private ImageView imageView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        editText = findViewById(R.id.editText);
        imageView = findViewById(R.id.imageView);
        findViewById(R.id.button).setOnClickListener(v -> {
            String text = editText.getText().toString();
            byte[] utf8Bytes = text.getBytes(StandardCharsets.UTF_8);
            String utf8BytesString = new String(utf8Bytes, StandardCharsets.UTF_8);
            if (!TextUtils.isEmpty(utf8BytesString)) {
                Bitmap qrCode = null;
                try {
                    qrCode = createQRCode(utf8BytesString);
                } catch (WriterException e) {
                    throw new RuntimeException(e);
                }
                imageView.setImageBitmap(qrCode);
            }
        });
    }
    private Bitmap createQRCode(String text) throws WriterException {
        QRCodeWriter qrCodeWriter = new QRCodeWriter();
        BitMatrix bitMatrix = qrCodeWriter.encode(text, BarcodeFormat.QR_CODE, 300, 300);
        Bitmap bitmap = Bitmap.createBitmap(300, 300, Bitmap.Config.RGB_565);
        for (int x = 0; x < 300; x++) {
            for (int y = 0; y < 300; y++) {
                bitmap.setPixel(x, y, bitMatrix.get(x, y) ? getResources().getColor(R.color.black) : getResources().getColor(R.color.white));
            }
        }
        return bitmap;
    }
}
```

八、github

[https://github.com/xxddccaa/generate_qrcode](https://github.com/xxddccaa/generate_qrcode)

【Android】【Java】【每日练手1】字符串的二维码生成器

manifest.xml加权限：





```python
<uses-permission
        android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"
        tools:ignore="ProtectedPermissions" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
```

oncreate加代码能向用户获取权限：
```python
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 1);
        }
        //申请写权限
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
        }
        //申请创建文件
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.MANAGE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.MANAGE_EXTERNAL_STORAGE}, 1);
        }
```

加一个方法：

```python
public static void createFileRecursion(String fileName, Integer height) throws IOException {
        Path path = Paths.get(fileName);
        if (Files.exists(path)) {
            return;
        }
        if (Files.exists(path.getParent())) {
            if (height == 0) {
                Files.createFile(path);
            } else {
                Files.createDirectory(path);
            }
        } else {
            createFileRecursion(path.getParent().toString(), height + 1);
            createFileRecursion(fileName, height);
        }
    }
```

实现写入：

```python
                        try {
                            String jsonPath="/sdcard/Download/1.json";
                            createFileRecursion(jsonPath, 0);
                            FileWriter fileWriter = new FileWriter(jsonPath);
                            fileWriter.write(String.valueOf(msg.obj));
                            fileWriter.flush();
                            fileWriter.close();
                            Log.i("JSON_WRITE", "jsonPath: " + jsonPath);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
```