javascript复制代码const http = require("http");

http
  .createServer((req, res) => {
    console.log(req.headers);
    res.end("Hello World!");
  })
  .listen(2048, () => console.log("server start"));

javascript复制代码import express from "express";
import bodyParser from "body-parser";
import { exec } from "child_process";
import path from "path";
import fs from "fs/promises";
import "./env.js";
const app = express();
const port = 1024; // 监听的端口号
let step = 1; // 记录步骤顺序的变量
app.use(bodyParser.json());
const projectPath = process.env.PROJECT_PATH ?? ""; // 项目路径
const destinationPath = process.env.DESTINATION_PATH ?? ""; // 目标路径，一般是nginx下的项目路径
const buildPath = process.env.BUILD_OUTPUT ?? ""; // 项目打包后输出路径，如dist，build等
const _log = (...args) => {
  console.log(new Date().toLocaleString(), ...args);
};
// 执行命令的辅助函数，返回Promise以处理异步执行
const executeCommand = (command) => {
  return new Promise((resolve, reject) => {
    _log(`步骤 ${step}：执行命令 "${command}"`);
    exec(command, (error, stdout, stderr) => {
      if (error) {
        console.error(`步骤 ${step}：执行命令出错：${error}`);
        console.error(stderr);
        reject(error);
      } else {
        _log(`步骤 ${step}：命令执行成功`);
        step++; // 执行成功，递增步骤数
        resolve(stdout);
      }
    });
  });
};

// 检查目标文件夹是否存在，如果不存在则创建，存在则清空
const ensureProjectFolder = async (projectPath) => {
  try {
    await fs.access(projectPath);
    const files = await fs.readdir(projectPath);
    for (const file of files) {
      const filePath = path.join(projectPath, file);
      const stat = await fs.stat(filePath);
      if (stat.isDirectory()) {
        await fs.rm(filePath, { recursive: true });
      } else {
        await fs.unlink(filePath);
      }
    }
  } catch (error) {
    // 如果文件夹不存在则创建
    await fs.mkdir(projectPath, { recursive: true });
  }
};


// 递归复制文件夹的函数
async function copyFolder(src, dest) {
  try {
    _log(`复制文件夹 "${src}" 到 "${dest}"`);
    await fs.mkdir(dest, { recursive: true });
    const files = await fs.readdir(src);
    for (const file of files) {
      const srcPath = path.join(src, file);
      const destPath = path.join(dest, file);
      const stats = await fs.stat(srcPath);
      if (stats.isDirectory()) {
        await copyFolder(srcPath, destPath);
      } else {
        await fs.copyFile(srcPath, destPath);
        _log(`文件 "${srcPath}" 复制到 "${destPath}"`);
      }
    }
    _log(`文件夹 "${src}" 成功复制到 "${dest}"`);
  } catch (error) {
    console.error("复制文件夹时出错:", error);
  }
}

app.post("/webhook", async (req, res) => {
  const payload = req.body;
  const head = req.headers;
  if (payload?.ref_type && head["x-gitea-event-type"] === "create") {
    _log("从 Gitea 接收到Tag事件:", payload);
    try {
      await ensureProjectFolder(projectPath);
      const agreement = "http";
      const gitCommand = `cd ${projectPath} && git clone ${agreement}://${
        process.env.GIT_USER_NAME
      }:${process.env.GIT_PASS_WORD}@${payload.repository.clone_url.replace(
        `${agreement}://`,
        ""
      )} ./`;
      await executeCommand(gitCommand);
      await executeCommand(`cd ${projectPath} && git checkout ${payload.ref}`);
      const pnpmInstalled = await executeCommand("pnpm -v")
        .then(() => true)
        .catch(() => false);
      if (!pnpmInstalled) {
        await executeCommand("npm install -g pnpm");
      }
      await executeCommand(`cd ${projectPath} && pnpm install`);
      await executeCommand(`cd ${projectPath} && pnpm build`);
      await ensureProjectFolder(destinationPath);
      await copyFolder(path.join(projectPath, buildPath), destinationPath);
      _log("部署成功");
      res.status(200).send("部署成功");
    } catch (error) {
      console.error("部署过程中出错:", error);
      res.status(500).send("部署失败");
    } finally {
      await ensureProjectFolder(projectPath);
      _log(`文件夹 "${projectPath}" 内容删除成功`);
    }
  } else {
    _log("从 Gitea 接收到不可识别的事件");
    res.status(400).send("不可识别的事件");
  }
});

app.listen(port, () => {
  _log(`服务器正在端口 ${port} 上运行`);
});

java复制代码String jsCode = String.format("window.showWebDialog('%s')", text);
webView.evaluateJavascript(jsCode, new ValueCallback<String>() {
  @Override
  public void onReceiveValue(String value) {

  }
});

java复制代码[webView evaluateJavaScript:@"执行的JS代码" 
  completionHandler:^(id _Nullable response, NSError * _Nullable error) {
  // 
}];

java复制代码<protocol>://<host>/<path>?<qeury>#fragment
  
// 我们可以自定义JSBridge通信的URL Schema，比如：
hellobike://showToast?text=hello

typescript复制代码  get existOrderRedirect() {
    let url: string;
    if (this.env.isHelloBikeApp) {
      url = 'hellobike://hellobike.com/xxxxx_xxx?from_type=xxxx&selected_tab=xxxxx';
    } else if (this.env.isSFCApp) {
      url = 'hellohitch://hellohitch.com/xxx/xxxx?bottomTab=xxxx';
    }
    return url;
  }

java复制代码// 注入全局JS对象
webView.addJavascriptInterface(new NativeBridge(this), "NativeBridge");

class NativeBridge {
    private Context ctx;
    NativeBridge(Context ctx) {
        this.ctx = ctx;
    }

    // 绑定方法
    @JavascriptInterface
    public void showNativeDialog(String text) {
        new AlertDialog.Builder(ctx).setMessage(text).create().show();
    }
}

java复制代码// 调用nativeBridge的方法
window.NativeBridge.showNativeDialog('hello');

typescript复制代码// 定义一个名为 callNative 的方法，用于在 JavaScript 中调用原生方法
callNative<P, R>(classMap: string, method: string, params: P): Promise<R> {
    return new Promise<R>((resolve, reject) => {
        // 生成一个唯一的回调 ID
        const id = v4();
        // 将当前的回调函数保存到 __callbacks 对象中，以 callbackId 作为键
        this.__callbacks[id] = { resolve, reject, method: `${classMap} - ${method}` };
        // 构造通信数据，包括原生类映射、要调用的方法、参数和 callbackId 
        const data = {
            classMap,
            method,
            params: params === null ? '' : JSON.stringify(params),
            callbackId: id,
        };
        const dataStr = JSON.stringify(data);
        // 根据当前环境判断是 iOS 还是 Android，并调用相应平台的原生方法
        if (this.env.isIOS && isFunction(window?.webkit?.messageHandlers?.callNative?.postMessage)) {
            // 如果是 iOS 平台，则调用 iOS 的原生方法
            window.webkit.messageHandlers.callNative.postMessage(dataStr);
        } else if (this.env.isAndroid && isFunction(window?.AppFunctions?.callNative)) {
            // 如果是 Android 平台，则调用 Android 的原生方法
            window.AppFunctions.callNative(dataStr);
        }
    });
}

typescript复制代码// 初始化桥接回调函数，该参数在 constructor 中调用
private initBridgeCallback() {
    // 保存旧的回调函数到 oldCallback 变量中
    const oldCallback = window.callBack;
    // 重新定义 window.callBack 方法，用于处理原生应用的回调数据
    window.callBack = (data) => {
        // 如果存在旧的回调函数，则调用旧的回调函数
        if (isFunction(oldCallback)) {
            oldCallback(data);
        }
        // 获取原生应用的回调信息，包括数据和回调 ID
        console.info('native callback', data, data.callbackId);
        // 从回调数据中获取回调 ID
        const { callbackId } = data;
        // 根据回调 ID 查找对应的回调函数
        const callback = this.__callbacks[callbackId];
        // 如果找到了对应的回调函数
        if (callback) {
            // 如果回调数据中的 code 为 0，则表示执行成功，调用 resolve 方法处理成功的结果
            if (data.code === 0) {
                callback.resolve(data.data);
            } else {
                // 否则，表示执行失败，构造一个错误对象并调用 reject 方法处理错误信息
                const error = new Error(data.msg) as Error & {response:unknown};
                error.response = data;
                callback.reject(error);
            }
            // 删除已经处理过的回调函数
            delete this.__callbacks[callbackId];
        }
    };
}

typescript复制代码// 调用原生方法的封装函数
callNative<P, R>(classMap: string, method: string, params: P) {
    // 从容器中解析出 AppBridge 实例
    const bridge = container.resolve<AppBridge>(AppBridge);
    // 使用 bind 方法将 AppBridge 实例中的 callNative 方法绑定到 bridge 对象上，并保存到 func 变量中
    const func = bridge.callNative.bind(bridge);
    // 调用 func 方法，并传入 classMap、method 和 params 参数，实现调用原生方法的功能
    return func<P, R>(classMap, method, params);
}


// 打开 webview
// 调用 callNative 方法，传入参数 url，classMap 为 'xxxxx/hitch'，method 为 'openWebview'
openWebView(url: string): Promise<void> {
    return this.callNative<{url:string}, void>('xxxxx/hitch', 'openWebview', { url });
}


// 获取驾驶证 OCR 信息
getDriverLicenseOcrInfo(
    params: HBNative.getDriverLicenseOcrInfo.Params,
): Promise<HBNative.getDriverLicenseOcrInfo.Result> {
    // 调用 callNative 方法，传入参数 params，classMap 为 'xxxxx/hitch'，method 为 'getOcrInfo'
    // 返回一个 Promise 对象，该 Promise 对象用于处理异步结果
    return this.callNative<
        HBNative.getDriverLicenseOcrInfo.Params,
        HBNative.getDriverLicenseOcrInfo.Result>(
            'xxxxx/hitch', 'getOcrInfo', params,
        );
}

kotlin复制代码private var number by mutableStateOf(1)

    @OptIn(ExperimentalMaterial3Api::class)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Android_VMTheme {
                Surface {
                    Text(text = "当前数值是: $number", modifier = Modifier.clickable {
                        number ++
                    })
                }
            }
        }
    }

kotlin复制代码private var nums by mutableStateOf(mutableListOf(1, 2, 3))

@OptIn(ExperimentalMaterial3Api::class)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
        Android_VMTheme {
            Surface {
                Column {
                    for (num in nums) {
                        Text(text = "当前是第 $num 的文字")
                    }
                }
            }
        }
    }
}

kotlin复制代码private var nums by mutableStateOf(mutableListOf(1, 2, 3))

    @OptIn(ExperimentalMaterial3Api::class)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Android_VMTheme {
                Surface {
                    Button(onClick = {
                        nums.add(nums.last() + 1)
                    }) {
                        Text(text = "添加内容")
                    }
                    Column {
                        for (num in nums) {
                            Text(text = "当前是第 $num 的文字")
                        }
                    }
                }
            }
        }
    }

kotlin复制代码private var number by mutableStateOf(1)
private var nums by mutableStateOf(mutableListOf(1, 2, 3))

@OptIn(ExperimentalMaterial3Api::class)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContent {
        Android_VMTheme {
            Surface {
                Column {
                    Text(text = "当前数值是: $number", modifier = Modifier.clickable {
                        number ++
                    })
                    Button(onClick = {
                        nums.add(nums.last() + 1)
                    }) {
                        Text(text = "添加内容")
                    }
                    Column {
                        for (num in nums) {
                            Text(text = "当前是第 $num 的文字")
                        }
                    }
                }
            }
        }
    }
}

ini复制代码Button(onClick = {
    nums = nums.toMutableList().apply {
        add(nums.last() + 1)
    }
}) {
    Text(text = "添加内容")
}

kotlin复制代码    private var nums = mutableStateListOf(1, 2, 3)

    @OptIn(ExperimentalMaterial3Api::class)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Android_VMTheme {
                Surface {
                    Column {
                        Text(text = "当前数值是: $number", modifier = Modifier.clickable {
                            number ++
                        })
                        Button(onClick = {
                            nums.add(nums.last() + 1)
                        }) {
                            Text(text = "添加内容")
                        }
                        Column {
                            for (num in nums) {
                                Text(text = "当前是第 $num 的文字")
                            }
                        }
                    }
                }
            }
        }
    }

yaml复制代码开始
  |
  v
初始化位数组为0，选择k个哈希函数
  |
  v
添加元素？
  |
  是 v 否
  |   |
  | 添加元素  返回结果
  |   |
  v   |
检查所有哈希位置  |
  | v
所有位置都为1？  |
  | 是 v 否
  | 元素可能存在 元素一定不存在
  | v
结束

arduino复制代码import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;

public class RedissonBloomFilterUtil<T> {

    private RBloomFilter<T> bloomFilter;

    public RedissonBloomFilterUtil(RedissonClient redissonClient, String name) {
        bloomFilter = redissonClient.getBloomFilter(name);
    }

    public void createFilter(long expectedInsertions, double falseProbability) {
        bloomFilter.tryInit(expectedInsertions, falseProbability);
    }

    public boolean add(T element) {
        return bloomFilter.add(element);
    }

    public boolean contains(T element) {
        return bloomFilter.contains(element);
    }
}

arduino复制代码import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class BloomFilterExample {

    public static void main(String[] args) {
        // 配置 Redisson 客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redissonClient = Redisson.create(config);

        // 创建布隆过滤器实例
        RedissonBloomFilterUtil<String> bloomFilterUtil = new RedissonBloomFilterUtil<>(redissonClient, "sampleBloomFilter");

        // 初始化布隆过滤器：预计插入数量为 1000，误判率为 0.03
        bloomFilterUtil.createFilter(1000, 0.03);

        // 添加元素
        bloomFilterUtil.add("element1");
        bloomFilterUtil.add("element2");

        // 检查元素是否存在
        System.out.println("Does bloom filter contain 'element1'? " + bloomFilterUtil.contains("element1")); // true
        System.out.println("Does bloom filter contain 'element3'? " + bloomFilterUtil.contains("element3")); // false (可能)

        // 关闭 Redisson 客户端
        redissonClient.shutdown();
    }
}

kotlin复制代码import androidx.activity.ComponentActivity
import androidx.core.util.Consumer

interface ICameraVideoHelper<in T> {

    /**
     * 使用相机API开始预览
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param view 根据不同的API可能传入不同的预览页面: SurfaceView、TextureView、PreviewView
     */
    fun startPreview(
        activity: ComponentActivity,
        view: T
    )

    /**
     * 使用相机API 拍视频
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param view 根据不同的API可能传入不同的预览页面: SurfaceView、TextureView、PreviewView
     * @param callback 结果回调
     */
    fun startRecord(
        activity: ComponentActivity,
        view: T,
        callback: Consumer<String>
    )

    /**
     * 缩放
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param zoom 缩放倍数
     */
    fun zoom(
        activity: ComponentActivity,
        zoom: Float
    )

    /**
     * 结束视频
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param callback 结果回调
     */
    fun stopRecord(
        activity: ComponentActivity,
        callback: Consumer<String>
    )

    /**
     * 释放资源
     */
    fun release()
}

kotlin复制代码/**
 * 使用Camera API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API使用的 SurfaceView
 */
override fun startPreview(
    activity: ComponentActivity,
    view: SurfaceView
) {
    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {

        // 1、获取后置摄像头ID, 默认 Camera.CameraInfo.CAMERA_FACING_BACK
        val cameraId = getCameraId(mFacingType)

        // 2、获取相机实例
        if (mCamera == null) {
            mCamera = Camera.open(cameraId)
        }

        // 3、设置和屏幕方向一致
        setCameraDisplayOrientation(activity, mCamera!!, cameraId)

        // 4、设置相机参数
        setCameraParameters(mCamera!!)

        // 5、在startPreview前设置holder(有前提: surfaceCreated已完成)
        // 不要在surfaceCreated设置，不然有问题，使用工具类没法收到surfaceCreated回调
        mCamera!!.setPreviewDisplay(view.holder)

        // 6、设置SurfaceHolder回调
        view.holder.addCallback(mSurfaceCallback)

        // 7、开始预览
        mCamera!!.startPreview()
    }
}

kotlin复制代码/**
 * 使用相机API拍视频
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view 使用 SurfaceView 拍视频
 * @param callback 结果回调
 */
override fun startRecord(
    activity: ComponentActivity,
    view: SurfaceView,
    callback: Consumer<String>
){
    // 创建一个 MediaRecorder 对象，或者重置
    if (mMediaRecorder == null) {
        mMediaRecorder = MediaRecorder()
    }

    // 释放相机资源，给mMediaRecorder使用
    mCamera?.unlock()

    // 设定参数
    mMediaRecorder!!.apply {

        // 绑定相机
        setCamera(mCamera)

        // 设置预览画面
        setPreviewDisplay(view.holder.surface)

        // 设置方向
        setOrientationHint(
            getCameraDisplayOrientation(activity, getCameraId(mFacingType)))

        // 设置视频参数
        setAudioSource(MediaRecorder.AudioSource.CAMCORDER)
        setVideoSource(MediaRecorder.VideoSource.CAMERA)

        // 设置尺寸，注意两者顺序
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setVideoSize(mPreviewSize.width, mPreviewSize.height)

        setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT)
        setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT)

        // 获取临时视频路径
        mTempPath = getTempVideoPath(activity).absolutePath

        // 设置输出文件路径
        setOutputFile(mTempPath)

        // 准备 MediaRecorder
        prepare()

        // 开始录制
        start()

        // 传出路径
        callback.accept(mTempPath)
    }
}

kotlin复制代码override fun zoom(
    activity: ComponentActivity,
    zoom: Float
){
    val params = mCamera!!.parameters

    // 检查设备是否支持变焦
    if (!params.isZoomSupported) {
        // 处理不支持的情况，例如提示用户或忽略请求
        return
    }

    // 确保缩放级别在允许的范围内
    val maxZoom = params.maxZoom
    val zoomLevel = kotlin.math.min(maxZoom, 1 + (zoom * (maxZoom - 1)).toInt())

    // 设置新的缩放级别
    params.zoom = zoomLevel

    // 应用新的参数到相机
    mCamera!!.parameters = params
}

kotlin复制代码override fun stopRecord(activity: ComponentActivity, callback: Consumer<String>) {
    mMediaRecorder?.let {
        var isTooShort = false
        try {
            // 时间过短无法stop
            it.stop()
        }catch (e: Exception) {
            isTooShort = true
            e.printStackTrace()
        }

        it.reset()
        mCamera?.lock()
        continuePreview()
        callback.accept(if (isTooShort) "" else mTempPath)
    }
}

kotlin复制代码/**
 * 释放资源
 */
override fun release() {
    mCamera?.stopPreview()
    mCamera?.release()
    mMediaRecorder?.release()
    mCamera = null
    mMediaRecorder = null
}

kotlin复制代码/**
 * 使用Camera2 API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API2使用的 TextureView(当然也能用SurfaceView)
 */
override fun startPreview(
    activity: ComponentActivity,
    view: TextureView
) {
    // 持有TextureView的弱引用，便于释放资源
    mTextureViewRef = WeakReference(view)

    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {

        // 1、获取CameraManager
        val cameraManager = ContextCompat.getSystemService(activity, CameraManager::class.java)
            ?: throw IllegalStateException("get cameraManager fail")

        // 2、获取摄像头mCameraId、摄像头信息mCameraCharacteristics
        chooseCameraIdByFacing(mFacingType, cameraManager)

        // 3. 获取预览和录像的尺寸(!!!N多错误都是尺寸造成的)
        getSizes()

        // 4、开启相机
        mCameraDevice = openCamera(cameraManager)

        // 5.创建预览Session
        val surface = getSurface(view)
        mPreviewSession = startCaptureSession(mutableListOf(
            // 注意一定要传入使用到的surface，不然会闪退
            surface
        ),  mCameraDevice!!)

        // 6.设置textureView回调，destroy时释放资源
        view.surfaceTextureListener = mTextureViewCallback

        // 7.开始预览，预览和拍照都用request实现
        preview(surface)
    }
}

kotlin复制代码private fun getSizes() {
    // 获取尺寸
    mCameraCharacteristics?.let { info ->
        val map = info.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!

        // !!!再次注意width比height更大，不然选不到对的size
        mVideoSize = getOptimalPreviewSize(
            map.getOutputSizes(MediaRecorder::class.java).toList(), 1920, 1080)
        mPreviewSize = getOptimalPreviewSize(
            map.getOutputSizes(MediaRecorder::class.java).toList(), 1920, 1080)
    }
}

kotlin复制代码/**
 * 使用相机API拍视频
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view 使用 TextureView 拍视频
 * @param callback 结果回调
 */
override fun startRecord(
    activity: ComponentActivity,
    view: TextureView,
    callback: Consumer<String>
){
    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.Main) {

        // 关闭预览对话
        closePreviewSession()

        // 设置MediaRecorder
        setUpMediaRecorder(activity, callback)

        // 创建
        mRecordRequestBuilder = mCameraDevice!!.createCaptureRequest(CameraDevice.TEMPLATE_RECORD)

        // 设置预览输出
        val previewSurface = getSurface(view)
        mRecordRequestBuilder!!.addTarget(previewSurface)

        // 设置录像输出
        val recorderSurface = mMediaRecorder!!.surface
        mRecordRequestBuilder!!.addTarget(recorderSurface)

        // 创建新的预览对话，能将视频输出到录像surface
        mPreviewSession = startCaptureSession(mutableListOf(
            previewSurface, recorderSurface
        ),  mCameraDevice!!)

        // 录像请求
        mRecordRequestBuilder!!.set(CaptureRequest.CONTROL_AF_MODE,
            CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_VIDEO)
        mPreviewSession!!.setRepeatingRequest(mRecordRequestBuilder!!.build(), null, mHandler)

        // 启动录制
        mMediaRecorder!!.start()
    }
}

kotlin复制代码private fun closePreviewSession() {
    mPreviewSession?.close()
    mPreviewSession = null
}

kotlin复制代码// 创建新的预览对话，能将视频输出到录像surface
mPreviewSession = startCaptureSession(mutableListOf(
    previewSurface, recorderSurface
),  mCameraDevice!!)

kotlin复制代码private fun setUpMediaRecorder(activity: ComponentActivity, callback: Consumer<String>) {
    // 创建一个 MediaRecorder 对象，或者重置
    if (mMediaRecorder == null) {
        mMediaRecorder = MediaRecorder()
    }

    // 设定参数
    mMediaRecorder!!.apply {

        // 设置视频参数(!!!注意视频不是从Camera来了)
        setAudioSource(MediaRecorder.AudioSource.MIC)
        setVideoSource(MediaRecorder.VideoSource.SURFACE)

        // 设置输出文件路径
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        mTempPath = getTempVideoPath(activity).absolutePath
        setOutputFile(mTempPath)

        // 设置比特率和帧率
        setVideoEncodingBitRate(100000000)
        setVideoFrameRate(30)

        // 设置尺寸，注意两者顺序
        setVideoSize(mVideoSize!!.width, mVideoSize!!.height)

        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
        setVideoEncoder(MediaRecorder.VideoEncoder.H264)

        // !!!不能掉了，不然prepare不会成功
        setOrientationHint(90)

        // 准备 MediaRecorder
        prepare()

        // 传出路径
        callback.accept(mTempPath)
    }
}

kotlin复制代码private fun getSizes() {
    // 获取尺寸
    mCameraCharacteristics?.let { info ->
        val map = info.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)!!

        // !!!再次注意width比height更大，不然选不到对的size
        mVideoSize = getOptimalPreviewSize(
            map.getOutputSizes(MediaRecorder::class.java).toList(), 1920, 1080)
        mPreviewSize = getOptimalPreviewSize(
            map.getOutputSizes(MediaRecorder::class.java).toList(), 1920, 1080)
    }
}

kotlin复制代码// 设置预览输出
val previewSurface = getSurface(view)
mRecordRequestBuilder!!.addTarget(previewSurface)

// 设置录像输出
val recorderSurface = mMediaRecorder!!.surface
mRecordRequestBuilder!!.addTarget(recorderSurface)

kotlin复制代码// 录像请求
mRecordRequestBuilder!!.set(CaptureRequest.CONTROL_AF_MODE,
    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_VIDEO)
mPreviewSession!!.setRepeatingRequest(mRecordRequestBuilder!!.build(), null, mHandler)

// 启动录制
mMediaRecorder!!.start()

kotlin复制代码override fun zoom(
    activity: ComponentActivity,
    zoom: Float
){
    // 缩放实际是通过修改Rect实现的
    val zoomRect = calculateZoomRect(zoom)
    // 这两行代码只是为了防止重复请求
    mPreviewSession?.stopRepeating()
    // 创建请求修改
    mRecordRequestBuilder!!.set(CaptureRequest.SCALER_CROP_REGION, zoomRect)
    mPreviewSession?.setRepeatingRequest(mRecordRequestBuilder!!.build(), null, mHandler)

}

private fun calculateZoomRect(zoomLevel: Float): Rect {
    val sensorRect = mCameraCharacteristics!!.get(
        CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)!!

    val minZoom = 1.0f
    val maxZoom = mCameraCharacteristics!!.get(
        CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM)!!
    val currentZoom = minZoom + (maxZoom - minZoom) * zoomLevel

    val centerX = sensorRect.width() / 2
    val centerY = sensorRect.height() / 2
    val deltaX = (0.5f * sensorRect.width() / currentZoom).toInt()
    val deltaY = (0.5f * sensorRect.height() / currentZoom).toInt()

    val zoomRect = Rect()
    zoomRect.left = centerX - deltaX
    zoomRect.right = centerX + deltaX
    zoomRect.top = centerY - deltaY
    zoomRect.bottom = centerY + deltaY

    return zoomRect
}

kotlin复制代码override fun stopRecord(activity: ComponentActivity, callback: Consumer<String>) {
    mMediaRecorder?.let {
        var isTooShort = false
        try {
            // 时间过短无法stop
            it.stop()
        }catch (e: Exception) {
            isTooShort = true
            e.printStackTrace()
        }

        it.reset()

        // 重新预览(外部去操作吧，这里不动了)
        // startPreview(activity, mTextureViewRef!!.get()!!)

        callback.accept(if (isTooShort) "" else mTempPath)
    }
}

kotlin复制代码override fun release() {
    // 从 SurfaceTexture 中移除 SurfaceTextureListener
    mTextureViewRef?.get()?.surfaceTextureListener = null
    // 需要关闭这三个
    mCameraDevice?.close()
    mPreviewSession?.close()
    mMediaRecorder?.release()
    mMediaRecorder = null
    mRecordRequestBuilder = null
    mHandler.removeCallbacksAndMessages(null)
}

toml复制代码# cameraX
camerax = "1.1.0-beta01"

# cameraX
camerax = { module = "androidx.camera:camera-core", version.ref = "camerax"}
camerax_camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax"}
camerax_video = { module = "androidx.camera:camera-video", version.ref = "camerax"}
camerax_lifecycler = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax"}
camerax_view = { module = "androidx.camera:camera-view", version.ref = "camerax"}
camerax_extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax"}

kotlin复制代码dependencies {
    //。。。

    // CameraX 相关依赖
    implementation(libs.camerax)
    implementation(libs.camerax.camera2)
    implementation(libs.camerax.lifecycler)
    implementation(libs.camerax.video)
    implementation(libs.camerax.view)
    implementation(libs.camerax.extensions)
}

kotlin复制代码/**
 * 使用CameraX API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API使用的 PreviewView
 */
@SuppressLint("RestrictedApi")
override fun startPreview(
    activity: ComponentActivity,
    view: PreviewView
) {
    val cameraProviderFuture = ProcessCameraProvider.getInstance(activity)
    cameraProviderFuture.addListener({
        // 用于将相机的生命周期绑定到生命周期所有者
        // 消除了打开和关闭相机的任务，因为 CameraX 具有生命周期感知能力
        mCameraProvider = cameraProviderFuture.get()

        // 预览
        val preview = Preview.Builder()
            .build()
            .also {
                it.setSurfaceProvider(view.surfaceProvider)
            }

        // 录像的使用场景
        val recorder = Recorder.Builder()
            .setQualitySelector(QualitySelector.from(Quality.HIGHEST))
            .build()
        videoCapture = VideoCapture.withOutput(recorder)

        // 选择摄像头，省去了去判断摄像头ID
        val cameraSelector = mSelector

        try {
            // Unbind use cases before rebinding
            mCameraProvider!!.unbindAll()

            // 将相机绑定到 lifecycleOwner，就不用手动关闭了
            mCamera = mCameraProvider!!.bindToLifecycle(
                activity, cameraSelector, preview, videoCapture)

        } catch(exc: Exception) {
            Log.e("TAG", "Use case binding failed", exc)
        }

        // 回调代码在主线程处理
    }, ContextCompat.getMainExecutor(activity))
}

kotlin复制代码/**
 * 使用相机API拍视频
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view 使用 PreviewView 拍视频
 * @param callback 结果回调
 */
@SuppressLint("MissingPermission")
override fun startRecord(
    activity: ComponentActivity,
    view: PreviewView,
    callback: Consumer<String>
){
    // 视频文件
    val videoFile = getTempVideoPath(activity)
    mTempPath = videoFile.absolutePath
    val outputFileOptions = FileOutputOptions.Builder(videoFile).build()

    // 录像(直接用videoCapture的写法预览会卡顿)
    mRecording = videoCapture!!.output
        .prepareRecording(activity, outputFileOptions)
        .apply {
            withAudioEnabled()
        }
        .start(ContextCompat.getMainExecutor(activity)) { recordEvent ->
            when(recordEvent) {
                is VideoRecordEvent.Start -> {}
                is VideoRecordEvent.Finalize -> {
                    if (!recordEvent.hasError()) {
                        mRecordEndCallback?.accept(mTempPath)
                    } else {
                        // 录制失败
                        mRecording?.close()
                        mRecording = null
                        mRecordEndCallback?.accept("")
                    }
                }
            }
        }

    // 传出地址
    callback.accept(mTempPath)
}

kotlin复制代码override fun zoom(
    activity: ComponentActivity,
    zoom: Float
){
    mCamera?.let {
        // 先获取最大缩放级别
        val zoomState = it.cameraInfo.zoomState
        val maxZoomRatio = zoomState.value?.maxZoomRatio ?: 1.0f
        // 设置缩放级别
        val zoomLevel = 1 + (zoom * (maxZoomRatio - 1))
        it.cameraControl.setZoomRatio(zoomLevel)
    }
}

kotlin复制代码try {
    // Unbind use cases before rebinding
    mCameraProvider!!.unbindAll()

    // 将相机绑定到 lifecycleOwner，就不用手动关闭了
    mCamera = mCameraProvider!!.bindToLifecycle(
        activity, cameraSelector, preview, videoCapture)

} catch(exc: Exception) {
    Log.e("TAG", "Use case binding failed", exc)
}

kotlin复制代码override fun stopRecord(activity: ComponentActivity, callback: Consumer<String>) {
    // 注意stopRecording是个异步方法，先保存下，在startRecording的callback里面触发
    mRecordEndCallback = callback
    mRecording!!.stop()
}

kotlin复制代码when(recordEvent) {
    is VideoRecordEvent.Start -> {}
    is VideoRecordEvent.Finalize -> {
        if (!recordEvent.hasError()) {
            mRecordEndCallback?.accept(mTempPath)
        } else {
            // 录制失败
            mRecording?.close()
            mRecording = null
            mRecordEndCallback?.accept("")
        }
    }
}

kotlin复制代码/**
 * 释放资源
 */
override fun release() {
    // 取消绑定生命周期观察者
    mCameraProvider?.unbindAll()
    mCameraProvider = null
    mRecordEndCallback = null
    mCamera = null
}

kotlin复制代码import android.graphics.Bitmap
import androidx.activity.ComponentActivity
import androidx.core.util.Consumer

interface ICameraCaptureHelper<in T> {

    /**
     * 使用相机API开始预览
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param view 根据不同的API可能传入不同的预览页面: SurfaceView、TextureView、PreviewView
     */
    fun startPreview(
        activity: ComponentActivity,
        view: T
    )

    /**
     * 使用相机API拍照
     *
     * @param activity 带lifecycle的activity，提供context，并且便于使用协程
     * @param view 根据不同的API可能传入不同的预览页面: SurfaceView、TextureView、PreviewView
     * @param callback 结果回调
     */
    fun takePhoto(
        activity: ComponentActivity,
        view: T,
        callback: Consumer<Bitmap>
    )

    /**
     * 释放资源
     */
    fun release()
}

kotlin复制代码/**
 * 使用Camera API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API使用的 SurfaceView
 */
override fun startPreview(
    activity: ComponentActivity,
    view: SurfaceView
) {
    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {

        // 1、获取后置摄像头ID: 默认 Camera.CameraInfo.CAMERA_FACING_BACK
        val cameraId = getCameraId(mFacingType)

        // 2、获取相机实例
        if (mCamera == null) {
            mCamera = Camera.open(cameraId)
        }

        // 3、设置和屏幕方向一致
        setCameraDisplayOrientation(activity, mCamera!!, cameraId)

        // 4、设置相机参数
        setCameraParameters(mCamera!!)

        // 5、在startPreview前设置holder(有前提: surfaceCreated已完成)
        // 不要在surfaceCreated设置，不然有问题，使用工具类没法收到surfaceCreated回调
        mCamera!!.setPreviewDisplay(view.holder)

        // 6、设置SurfaceHolder回调
        view.holder.addCallback(mSurfaceCallback)

        // 7、开始预览
        mCamera!!.startPreview()
    }
}

kotlin复制代码private fun setCameraParameters(camera: Camera) {
    val params = camera.parameters

    // 设置图像格式
    params.previewFormat = ImageFormat.NV21

    // 设置预览尺寸(注意相机方向是width>height)
    val previewSize = getOptimalPreviewSize(params.supportedPreviewSizes, 1920, 1080)
    params.setPreviewSize(previewSize.width, previewSize.height)

    // 设置图片尺寸
    params.setPictureSize(previewSize.width, previewSize.height)

    // 设置对焦模式
    params.focusMode = Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE

    // 设置闪光灯模式
    params.flashMode = Camera.Parameters.FLASH_MODE_AUTO

    // 设置场景模式
    params.sceneMode = Camera.Parameters.SCENE_MODE_AUTO

    // 应用参数设置
    camera.parameters = params
}

private fun getOptimalPreviewSize(sizes: List<Camera.Size>, w: Int, h: Int): Camera.Size {
    val targetRatio = w.toDouble() / h
    return sizes.minByOrNull { abs(it.width.toDouble() / it.height - targetRatio) } ?: sizes[0]
}

kotlin复制代码/**
 * 使用相机API拍照
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view SurfaceView
 * @param callback 结果回调
 */
override fun takePhoto(
    activity: ComponentActivity,
    view: SurfaceView,
    callback: Consumer<Bitmap>
) {
    // camera1 API需要先预览才能拍照
    if (mCamera == null) {
        throw IllegalStateException("camera not prepared!!!")
    }

    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {
        mCamera!!.takePicture(null, null) { data, _ ->

            // 处理拍照结果
            val bitmap = BitmapFactory.decodeByteArray(data, 0, data.size)
            val cameraInfo = Camera.CameraInfo()
            Camera.getCameraInfo(Camera.CameraInfo.CAMERA_FACING_BACK, cameraInfo)
            val rotation = cameraInfo.orientation

            // 将结果投递到UI线程
            activity.lifecycleScope.launch(Dispatchers.Main) {
                callback.accept(rotateBitmap(bitmap, rotation))
            }
        }
    }
}

private fun rotateBitmap(bitmap: Bitmap, degrees: Int): Bitmap {
    val matrix = Matrix()
    matrix.postRotate(degrees.toFloat())
    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
}

kotlin复制代码/**
 * 释放资源
 */
override fun release() {
    mCamera?.stopPreview()
    mCamera?.release()
    mCamera = null
}

kotlin复制代码/**
 * 使用Camera2 API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API2使用的 TextureView(当然也能用SurfaceView)
 */
override fun startPreview(
    activity: ComponentActivity,
    view: TextureView
) {
    // 持有TextureView的弱引用，便于释放资源
    mTextureViewRef = WeakReference(view)

    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {

        // 1、获取CameraManager
        val cameraManager = ContextCompat.getSystemService(activity, CameraManager::class.java)
            ?: throw IllegalStateException("get cameraManager fail")

        // 2、获取摄像头mCameraId、摄像头信息mCameraCharacteristics
        // 默认 CameraCharacteristics.LENS_FACING_BACK
        chooseCameraIdByFacing(mFacingType, cameraManager)

        // 3、开启相机
        mCameraDevice = openCamera(cameraManager)

        // 4、设置如何读取图片的ImageReader
        mImageReader = getImageReader()

        // 5.创建Capture Session
        val surface = getSurface(view)
        mSession = startCaptureSession(mutableListOf(
            // 注意一定要传入使用到的surface，不然会闪退
            surface,
            mImageReader!!.surface
        ),  mCameraDevice!!)

        // 6.设置textureView回调
        view.surfaceTextureListener = mTextureViewCallback

        // 7.开始预览，预览和拍照都用request实现
        preview(surface)
    }
}

kotlin复制代码// 5.创建Capture Session
val surface = getSurface(view)
mSession = startCaptureSession(mutableListOf(
    // 注意一定要传入使用到的surface，不然会闪退
    surface,
    mImageReader!!.surface
),  mCameraDevice!!)

kotlin复制代码val map = info.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    ?: throw IllegalStateException("Cannot get available preview/video sizes")
val largest = map.getOutputSizes(ImageFormat.JPEG).maxByOrNull { it.width * it.height }
mLargestSize = largest ?: throw IllegalStateException("Cannot get largest preview size")

kotlin复制代码private fun preview(surface: Surface) {
    // 通过模板创建RequestBuilder
    // CaptureRequest还可以配置很多其他信息，例如图像格式、图像分辨率、传感器控制、闪光灯控制、
    // 3A(自动对焦-AF、自动曝光-AE和自动白平衡-AWB)控制等
    val previewRequestBuilder =
        mCameraDevice!!.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)

    // 设置预览画面
    previewRequestBuilder.addTarget(surface)

    mPreviewRequest = previewRequestBuilder.build()
    mSession!!.setRepeatingRequest(mPreviewRequest!!, null, mHandler)
}

kotlin复制代码/**
 * 使用相机API拍照
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera2 API使用的 TextureView(当然也能用SurfaceView)
 * @param callback 结果回调
 */
override fun takePhoto (
    activity: ComponentActivity,
    view: TextureView,
    callback: Consumer<Bitmap>
) {
    // IO协程中执行，
    activity.lifecycleScope.launch(Dispatchers.IO) {

        // 1、创建拍照的请求
        val captureRequestBuilder =
            mCameraDevice!!.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE)

        // 2、设置参数
        captureRequestBuilder.addTarget(mImageReader!!.surface)
        captureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO)

        // 3、设置拍照方向
        val rotation = activity.windowManager.defaultDisplay.rotation
        captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION,
            getJpegOrientation(mCameraCharacteristics!!, rotation))

        mCaptureRequest = captureRequestBuilder.build()

        // 4、拍照
        // mSession?.stopRepeating() // 这行代码只是为了防止重复请求
        // mSession?.abortCaptures() // 这行代码只是为了防止重复请求
        mSession!!.capture(mCaptureRequest!!, object : CameraCaptureSession.CaptureCallback() {
            override fun onCaptureCompleted(
                session: CameraCaptureSession,
                request: CaptureRequest,
                result: TotalCaptureResult
            ) {
                // 图片已捕获
                // 可选步骤，根据需要进行处理
            }
        }, mHandler)

        // 5、设置图片回调，拿到结果
        setImageReaderCallback(callback)
    }
}

private fun setImageReaderCallback(callback: Consumer<Bitmap>) {
    mImageReader?.setOnImageAvailableListener({
        val image = mImageReader!!.acquireNextImage()
        image?.use {
            val planes = it.planes
            if (planes.isNotEmpty()) {
                val buffer = planes[0].buffer
                val data = ByteArray(buffer.remaining())
                buffer.get(data)

                // 转成bitmap
                val bitmap = BitmapFactory.decodeByteArray(data, 0, data.size)

                // 传递结果，mHandler应该是在UI线程了
                callback.accept(bitmap)
            }
        }
    }, mHandler)
}

kotlin复制代码override fun release() {
    // 从 SurfaceTexture 中移除 SurfaceTextureListener
    mTextureViewRef?.get()?.surfaceTextureListener = null
    // 需要关闭这三个
    mCameraDevice?.close()
    mSession?.close()
    mImageReader?.close()
    mHandler.removeCallbacksAndMessages(null)
}

toml复制代码# cameraX
camerax = "1.1.0-beta01"

# cameraX
camerax = { module = "androidx.camera:camera-core", version.ref = "camerax"}
camerax_camera2 = { module = "androidx.camera:camera-camera2", version.ref = "camerax"}
camerax_video = { module = "androidx.camera:camera-video", version.ref = "camerax"}
camerax_lifecycler = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax"}
camerax_view = { module = "androidx.camera:camera-view", version.ref = "camerax"}
camerax_extensions = { module = "androidx.camera:camera-extensions", version.ref = "camerax"}

kotlin复制代码dependencies {
    //。。。

    // CameraX 相关依赖
    implementation(libs.camerax)
    implementation(libs.camerax.camera2)
    implementation(libs.camerax.lifecycler)
    implementation(libs.camerax.video)
    implementation(libs.camerax.view)
    implementation(libs.camerax.extensions)
}

kotlin复制代码/**
 * 使用CameraX API进行预览
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camera API使用的 PreviewView
 */
override fun startPreview(
    activity: ComponentActivity,
    view: PreviewView
) {
    val cameraProviderFuture = ProcessCameraProvider.getInstance(activity)
    cameraProviderFuture.addListener({
        // 用于将相机的生命周期绑定到生命周期所有者
        // 消除了打开和关闭相机的任务，因为 CameraX 具有生命周期感知能力
        mCameraProvider = cameraProviderFuture.get()

        // 预览
        val preview = Preview.Builder()
            .build()
            .also {
                it.setSurfaceProvider(view.surfaceProvider)
            }

        // 拍照的使用场景
        imageCapture = ImageCapture.Builder()
            .build()

        // 选择摄像头，省去了去判断摄像头ID
        // 默认 CameraSelector.DEFAULT_BACK_CAMERA
        val cameraSelector = mSelector

        try {
            // Unbind use cases before rebinding
            mCameraProvider!!.unbindAll()

            // 将相机绑定到 lifecycleOwner，就不用手动关闭了
            mCameraProvider!!.bindToLifecycle(
                activity, cameraSelector, preview, imageCapture)

        } catch(exc: Exception) {
            Log.e("TAG", "Use case binding failed", exc)
        }

        // 回调代码在主线程处理
    }, ContextCompat.getMainExecutor(activity))
}

kotlin复制代码/**
 * 使用相机API拍照
 *
 * @param activity 带lifecycle的activity，提供context，并且便于使用协程
 * @param view Camerax API使用的 PreviewView
 * @param callback 结果回调
 */
override fun takePhoto (
    activity: ComponentActivity,
    view: PreviewView,
    callback: Consumer<Bitmap>
) {
    // Get a stable reference of the modifiable image capture use case
    val imageCapture = imageCapture ?: return

    // 直接拍照拿bitmap，存文件可以用 OutputFileOptions
    imageCapture.takePicture(
        ContextCompat.getMainExecutor(activity),
        object : ImageCapture.OnImageCapturedCallback() {
            override fun onCaptureSuccess(image: ImageProxy) {
                // 转换为 Bitmap，并传递结果
                callback.accept(imageProxyToBitmap(image))
                image.close()
            }

            override fun onError(exc: ImageCaptureException) {
                // 处理拍摄过程中的异常
                Log.e("TAG", "Photo capture failed: ${exc.message}", exc)
            }
        }
    )
}

private fun imageProxyToBitmap(image: ImageProxy): Bitmap {
    val planeProxy = image.planes[0]
    val buffer = planeProxy.buffer

    val bytes = ByteArray(buffer.remaining())
    buffer.get(bytes)

    return BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
}

kotlin复制代码/**
 * 释放资源
 */
override fun release() {
    // 取消绑定生命周期观察者
    mCameraProvider?.unbindAll()
}