#import "GMObjC.h"

NSString *str = @"123@1234";
NSString *digest = [GMSm3Utils hashWithText:str];
NSLog(@"%@", digest);

#import "GMObjC/GMObjC.h"

NSString *digest1 = [GMSm3Utils hashWithText:str];
NSLog(@"%@", digest1);

# 创建合并包 GMObjC.xcframework

xcodebuild -create-xcframework \
           -framework Release-iphoneos/GMObjC.framework \
           -framework Release-iphonesimulator/GMObjC.framework \
           -output GMObjC.xcframework

# 安装 GMObjC 的源码和 GMOpenSSL.xcframework (静态库)
pod 'GMObjC', '~> 4.0.3'

# 当 Podfile 中使用 use_frameworks! 时，安装 GMObjC.xcframework (动态库)
pod 'GMDynamic', '~> 4.0.3'

#!/bin/bash
set -e

# 确保使用正确的路径
export PATH="/usr/local/bin:$PATH"

# 设置环境变量
export XCODE_PATH=$(xcode-select -p)
export IOS_SDK=$XCODE_PATH/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk
export SIM_SDK=$XCODE_PATH/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk

# 创建输出目录
OUTPUT_DIR="build-ios"
rm -rf $OUTPUT_DIR
mkdir -p $OUTPUT_DIR

# 编译函数
compile_arch() {
    ARCH=$1
    SDK=$2
    
    BUILD_DIR="${OUTPUT_DIR}/${ARCH}"
    mkdir -p $BUILD_DIR
    pushd $BUILD_DIR > /dev/null
    
    echo "▸ 配置 $ARCH..."
    cmake ../.. \
        -DCMAKE_SYSTEM_NAME=iOS \
        -DCMAKE_OSX_ARCHITECTURES=$ARCH \
        -DCMAKE_OSX_SYSROOT=$SDK \
        -DCMAKE_OSX_DEPLOYMENT_TARGET=13.0 \
        -DCMAKE_BUILD_TYPE=Release \
        -DBUILD_SHARED_LIBS=OFF \
        -DENABLE_SM2=ON \
        -DENABLE_SM3=ON \
        -DENABLE_SM4=ON \
        -DENABLE_SM9=ON \
        -G Ninja
        
    echo "▸ 编译 $ARCH..."
    ninja
    
    # 关键修改：GmSSL 3.x 生成的库是 libgmssl.a
    mkdir -p lib
    cp bin/libgmssl.a lib/
    
    popd > /dev/null
}

# 编译各架构
compile_arch "arm64" "$IOS_SDK"
compile_arch "x86_64" "$SIM_SDK"

# 合并通用库
UNIVERSAL_DIR="${OUTPUT_DIR}/universal"
mkdir -p $UNIVERSAL_DIR/lib

# 合并为单个库 (GmSSL 3.x 只生成一个库)
lipo -create \
    "${OUTPUT_DIR}/arm64/lib/libgmssl.a" \
    "${OUTPUT_DIR}/x86_64/lib/libgmssl.a" \
    -output "$UNIVERSAL_DIR/lib/libgmssl.a"

# 复制头文件
if [ -d "${OUTPUT_DIR}/arm64/include" ]; then
    cp -R "${OUTPUT_DIR}/arm64/include" "$UNIVERSAL_DIR/"
elif [ -d "../../include" ]; then
    cp -R "../../include" "$UNIVERSAL_DIR/"
else
    echo "⚠️ 警告: 找不到头文件目录"
fi

echo "✅ 编译成功！"
echo "库文件位置: $UNIVERSAL_DIR/lib/libgmssl.a"
echo "头文件位置: $UNIVERSAL_DIR/include"

# 验证文件
file "$UNIVERSAL_DIR/lib"/*.a
lipo -info "$UNIVERSAL_DIR/lib/libgmssl.a"

# 安装构建工具
brew install cmake ninja pkg-config

# 获取最新代码
git clone https://github.com/guanzhi/GmSSL.git
cd GmSSL
git checkout master  # 确保使用最新版本
git pull

# 2. 执行编译
chmod +x build_ios.sh
./build_ios.sh

@interface GmSSLEncryptorSM3 : NSObject

+ (NSString *)sm3HashWithString:(NSString *)input;
+ (NSData *)sm3HashWithData:(NSData *)data;

@end

@implementation GmSSLEncryptorSM3

+ (instancetype)encryptor {
    return [[GmSSLEncryptorSM3 alloc] init];
}

+ (NSData *)sm3HashWithData:(NSData *)data {
    // 初始化 SM3 上下文
    SM3_CTX ctx;
    sm3_init(&ctx);
    // 添加数据到哈希计算
    sm3_update(&ctx, data.bytes, data.length);
    // 准备存储结果的缓冲区 (SM3 输出为 32 字节)
    uint8_t dgst[SM3_DIGEST_SIZE];
    // 完成哈希计算
    sm3_finish(&ctx, dgst);
    // 转换为 NSData
    return [NSData dataWithBytes:dgst length:SM3_DIGEST_SIZE];
}

+ (NSString *)sm3HashWithString:(NSString *)input {
    NSData *inputData = [input dataUsingEncoding:NSUTF8StringEncoding];
    // 计算 SM3 哈希
    NSData *hashData = [GmSSLEncryptorSM3 sm3HashWithData:inputData];
    // 转换为十六进制字符串显示
    NSMutableString *hexString = [NSMutableString string];
    const uint8_t *bytes = (const uint8_t *)hashData.bytes;
    for (NSUInteger i = 0; i < hashData.length; i++) {
        [hexString appendFormat:@"%02x", bytes[i]];
    }
    return hexString;
}
@end

NSString *encryptor = [GmSSLEncryptorSM3 sm3HashWithString:str];
NSLog(@"%@", encryptor);

//
//  SM3Encryptor.m
//  testDemo
//
//  Created by wt on 2025/6/12.
//

#import "SM3Encryptor.h"
#include <stdint.h>

// SM3 上下文结构
typedef struct {
    uint32_t state[8];   // 8个32位寄存器（A-H）
    uint64_t totalLength; // 总消息长度（位）
    uint8_t buffer[64];  // 当前数据块缓存
    uint32_t bufferLength; // 当前缓冲区长度
} SM3Context;

// 循环左移
static inline uint32_t ROTL(uint32_t x, uint8_t n) {
    return (x << n) | (x >> (32 - n));
}

// 布尔函数 FF0（0≤j≤15）
static inline uint32_t FF0(uint32_t x, uint32_t y, uint32_t z) {
    return x ^ y ^ z;
}

// 布尔函数 FF1（16≤j≤63）
static inline uint32_t FF1(uint32_t x, uint32_t y, uint32_t z) {
    return (x & y) | (x & z) | (y & z);
}

// 布尔函数 GG0（0≤j≤15）
static inline uint32_t GG0(uint32_t x, uint32_t y, uint32_t z) {
    return x ^ y ^ z;
}

// 布尔函数 GG1（16≤j≤63）
static inline uint32_t GG1(uint32_t x, uint32_t y, uint32_t z) {
    return (x & y) | ((~x) & z);
}

// 置换函数 P0
static inline uint32_t P0(uint32_t x) {
    return x ^ ROTL(x, 9) ^ ROTL(x, 17);
}

// 置换函数 P1
static inline uint32_t P1(uint32_t x) {
    return x ^ ROTL(x, 15) ^ ROTL(x, 23);
}

// 初始化SM3上下文
void SM3Init(SM3Context *context) {
    // SM3标准初始值
    context->state[0] = 0x7380166F;
    context->state[1] = 0x4914B2B9;
    context->state[2] = 0x172442D7;
    context->state[3] = 0xDA8A0600;
    context->state[4] = 0xA96F30BC;
    context->state[5] = 0x163138AA;
    context->state[6] = 0xE38DEE4D;
    context->state[7] = 0xB0FB0E4E;
    context->totalLength = 0;
    context->bufferLength = 0;
    memset(context->buffer, 0, 64);
}

// 处理单个64字节块（压缩函数核心）
void SM3Compress(SM3Context *context, const uint8_t block[64]) {
    // 1. 消息扩展：16字 → 68字（W） + 64字（W1）
    uint32_t W[68], W1[64];
    
    // 初始化前16字（大端序转换）
    for (int i = 0; i < 16; i++) {
        W[i] = (uint32_t)block[i*4] << 24 |
               (uint32_t)block[i*4+1] << 16 |
               (uint32_t)block[i*4+2] << 8 |
               (uint32_t)block[i*4+3];
    }
    
    // 计算W[16]-W[67]
    for (int j = 16; j < 68; j++) {
        uint32_t temp = W[j-16] ^ W[j-9] ^ ROTL(W[j-3], 15);
        W[j] = P1(temp) ^ ROTL(W[j-13], 7) ^ W[j-6];
    }
    
    // 计算W1[0]-W1[63]
    for (int j = 0; j < 64; j++) {
        W1[j] = W[j] ^ W[j+4];
    }
    
    // 2. 寄存器初始化（A-H）
    uint32_t A = context->state[0];
    uint32_t B = context->state[1];
    uint32_t C = context->state[2];
    uint32_t D = context->state[3];
    uint32_t E = context->state[4];
    uint32_t F = context->state[5];
    uint32_t G = context->state[6];
    uint32_t H = context->state[7];
    
    // 3. 64轮迭代（严格遵循标准）
    for (int j = 0; j < 64; j++) {
        uint32_t SS1, SS2, TT1, TT2;
        
        // 常量选择（关键修正）
        uint32_t TJ = (j < 16) ? 0x79CC4519 : 0x7A879D8A;
        
        // 计算SS1/SS2（修正了TJ参数）
        SS1 = ROTL(ROTL(A, 12) + E + ROTL(TJ, j % 32), 7);
        SS2 = SS1 ^ ROTL(A, 12);
        
        // 计算TT1/TT2（使用内联函数）
        if (j < 16) {
            TT1 = FF0(A, B, C) + D + SS2 + W1[j];
            TT2 = GG0(E, F, G) + H + SS1 + W[j];
        } else {
            TT1 = FF1(A, B, C) + D + SS2 + W1[j];
            TT2 = GG1(E, F, G) + H + SS1 + W[j];
        }
        
        // 更新寄存器（严格顺序）
        D = C;
        C = ROTL(B, 9);
        B = A;
        A = TT1;
        H = G;
        G = ROTL(F, 19);
        F = E;
        E = P0(TT2);
    }
    
    // 4. 更新最终状态（与初始IV异或）
    context->state[0] ^= A;
    context->state[1] ^= B;
    context->state[2] ^= C;
    context->state[3] ^= D;
    context->state[4] ^= E;
    context->state[5] ^= F;
    context->state[6] ^= G;
    context->state[7] ^= H;
}

// 更新数据（可分多次调用）
void SM3Update(SM3Context *context, const uint8_t *data, size_t length) {
    context->totalLength += length * 8; // 更新总位数（字节转位）
    
    // 处理缓冲区中的剩余空间
    if (context->bufferLength > 0) {
        size_t copySize = MIN(64 - context->bufferLength, length);
        memcpy(context->buffer + context->bufferLength, data, copySize);
        context->bufferLength += copySize;
        data += copySize;
        length -= copySize;
        
        if (context->bufferLength == 64) {
            SM3Compress(context, context->buffer);
            context->bufferLength = 0;
        }
    }
    
    // 处理完整块
    while (length >= 64) {
        SM3Compress(context, data);
        data += 64;
        length -= 64;
    }
    
    // 缓存剩余数据
    if (length > 0) {
        memcpy(context->buffer, data, length);
        context->bufferLength = length;
    }
}

// 完成哈希计算
void SM3Final(SM3Context *context, uint8_t output[32]) {
    // 计算填充长度（SM3标准：补位1 + k个0 + 64位长度）
    size_t totalBits = context->totalLength;
    size_t paddingBits = (context->bufferLength < 56) ?
                         (56 - context->bufferLength) :
                         (120 - context->bufferLength);
    
    // 构建填充数据
    uint8_t padding[128] = {0};
    padding[0] = 0x80; // 补位起始位（二进制10000000）
    
    // 添加填充
    SM3Update(context, padding, paddingBits);
    
    // 添加消息长度（大端序64位）
    uint64_t bitCount = CFSwapInt64HostToBig(totalBits);
    SM3Update(context, (uint8_t *)&bitCount, 8);
    
    // 确保最后一个块被处理
    if (context->bufferLength > 0) {
        memset(context->buffer + context->bufferLength, 0, 64 - context->bufferLength);
        SM3Compress(context, context->buffer);
    }
    
    // 输出最终哈希（256位，大端序）
    for (int i = 0; i < 8; i++) {
        output[i*4]     = (uint8_t)(context->state[i] >> 24);
        output[i*4 + 1] = (uint8_t)(context->state[i] >> 16);
        output[i*4 + 2] = (uint8_t)(context->state[i] >> 8);
        output[i*4 + 3] = (uint8_t)(context->state[i]);
    }
}

// Objective-C 封装接口
@implementation SM3Encryptor

+ (NSData *)hashWithData:(NSData *)inputData {
    SM3Context context;
    SM3Init(&context);
    
    // 处理输入数据
    SM3Update(&context, inputData.bytes, inputData.length);
    
    // 获取结果
    uint8_t output[32];
    SM3Final(&context, output);
    
    return [NSData dataWithBytes:output length:32];
}

+ (NSString *)hexStringWithData:(NSData *)inputData {
    NSData *hashData = [self hashWithData:inputData];
    const uint8_t *bytes = (const uint8_t *)hashData.bytes;
    NSMutableString *hex = [NSMutableString string];
    
    for (NSUInteger i = 0; i < hashData.length; i++) {
        [hex appendFormat:@"%02X", bytes[i]];
    }
    
    return [hex copy];
}

+ (NSString *)hexStringWithInput:(NSString *)inputStr {
    NSData *inputData = [inputStr dataUsingEncoding:NSUTF8StringEncoding];
    NSData *hashData = [self hashWithData:inputData];
    const uint8_t *bytes = (const uint8_t *)hashData.bytes;
    NSMutableString *hex = [NSMutableString string];
    
    for (NSUInteger i = 0; i < hashData.length; i++) {
        [hex appendFormat:@"%02X", bytes[i]];
    }
    
    return [hex copy];
}


@end

# 设置绝对路径
BLOG_DIR="实际路径/blog"

# 进入博客目录
cd "$BLOG_DIR" || exit 1

# Hexo操作
hexo clean
hexo generate
hexo deploy

# 源文件备份
git add .
git commit -m "自动备份: $(date +"%Y-%m-%d %H:%M")"
git push origin main

chmod +x deploy.sh

const fs = require('fs-extra');
const path = require('path');
const { promisify } = require('util');
const exec = promisify(require('child_process').exec);

hexo.extend.filter.register('before_generate', async function() {
  const baseDir = hexo.base_dir;
  const currentSite = process.env.HEXO_SITE || 'kind';
  
  const sites = {
    kind: {
      exclusiveDir: 'source/_posts_kind',
      commonDir: 'source/_posts',
      output: 'public_kind',
      config: '_config.yml'
    },
    gavin: {
      exclusiveDir: 'source/_posts_gavin',
      commonDir: 'source/_posts',
      output: 'public_gavin',
      config: '_config_gavin.yml'
    }
  };
  
  const site = sites[currentSite];
  if (!site) return;
  
  // 创建临时源目录
  const tempSourceDir = path.join(baseDir, `temp_source_${currentSite}`);
  fs.ensureDirSync(tempSourceDir);
  fs.emptyDirSync(tempSourceDir);
  
  // 1. 复制整个source目录（包括所有共享文件）
  fs.copySync(path.join(baseDir, 'source'), tempSourceDir);
  
  // 2. 清空临时源目录的_posts文件夹
  const tempPostsDir = path.join(tempSourceDir, '_posts');
  fs.ensureDirSync(tempPostsDir);
  fs.emptyDirSync(tempPostsDir);
  
  // 3. 复制共同文章
  const commonPosts = path.join(baseDir, site.commonDir);
  if (fs.existsSync(commonPosts)) {
    fs.readdirSync(commonPosts).forEach(file => {
      if (file.endsWith('.md')) {
        fs.copySync(
          path.join(commonPosts, file),
          path.join(tempPostsDir, file)
        );
      }
    });
  }
  
  // 4. 复制专属文章
  const exclusivePosts = path.join(baseDir, site.exclusiveDir);
  if (fs.existsSync(exclusivePosts)) {
    fs.readdirSync(exclusivePosts).forEach(file => {
      if (file.endsWith('.md')) {
        fs.copySync(
          path.join(exclusivePosts, file),
          path.join(tempPostsDir, file)
        );
      }
    });
  }
  
  // 5. 动态应用配置
  hexo.config.source_dir = tempSourceDir;
  hexo.config.public_dir = site.output;
  
  // 6. 验证复制结果
  const postCount = fs.readdirSync(tempPostsDir).length;
  hexo.log.info(`✅ ${currentSite} 站点准备完成: ${postCount} 篇文章`);
});

// 添加部署后清理钩子
hexo.extend.filter.register('after_deploy', function() {
  const baseDir = hexo.base_dir;
  const currentSite = process.env.HEXO_SITE;
  
  if (currentSite) {
    const tempSourceDir = path.join(baseDir, `temp_source_${currentSite}`);
    if (fs.existsSync(tempSourceDir)) {
      fs.removeSync(tempSourceDir);
      hexo.log.info(`🧹 清理临时目录: ${tempSourceDir}`);
    }
  }
});

#!/usr/bin/env bash

# 配置区
BLOG_DIR="/Users/dianyin/Desktop/blog"
SOURCE_BRANCH="master"
PRIVATE_REPO_KIND="git@github.com-kind:kindyourself/blog-source.git"
PRIVATE_REPO_GAVIN="git@github.com-gavin:gavincarter1991/blog-source.git"

cd "$BLOG_DIR" || { echo "❌ 无法进入博客目录"; exit 1; }

# 清理上次生成的临时文件
rm -rf temp_source_* public*
hexo clean

# 生成 Kind 站点
echo "===== 🚀 生成 Kind 站点 ====="
export HEXO_SITE="kind"
hexo generate --config _config.yml

# 验证生成结果
echo "Kind 站点内容:"
ls -lh public_kind
tree -L 2 public_kind | head -20

# 生成 Gavin 站点
echo "===== 🚀 生成 Gavin 站点 ====="
export HEXO_SITE="gavin"
hexo generate --config _config_gavin.yml

# 验证生成结果
echo "Gavin 站点内容:"
ls -lh public_gavin
tree -L 2 public_gavin | head -20

# 部署到GitHub Pages
echo "===== 🚀 部署到 GitHub Pages ====="
echo "部署 Kind 站点..."
export HEXO_SITE="kind"
hexo deploy --config _config.yml

echo "部署 Gavin 站点..."
export HEXO_SITE="gavin"
hexo deploy --config _config_gavin.yml

# 备份到私有仓库
echo "===== 📦 备份源文件到私有仓库 ====="
git add .
if git diff-index --quiet HEAD --; then
    echo "🔄 无文件变更"
else
    git commit -m "自动备份: $(date +"%Y-%m-%d %H:%M:%S")"
    
    # 推送到两个私有仓库
    git push "$PRIVATE_REPO_KIND" "$SOURCE_BRANCH" && \
        echo "✅ kindyourself/blog-source 备份成功" || \
        echo "❌ kindyourself/blog-source 备份失败"
    
    git push "$PRIVATE_REPO_GAVIN" "$SOURCE_BRANCH" && \
        echo "✅ gavincarter1991/blog-source 备份成功" || \
        echo "❌ gavincarter1991/blog-source 备份失败"
fi

echo "===== ✅ 部署完成 ====="
echo "博客地址1: https://kindyourself.github.io"
echo "博客地址2: https://gavincarter1991.github.io"

class IconTextButton extends StatelessWidget {
  final String iconName;
  final String label;
  final VoidCallback onPressed;

  const IconTextButton({
    super.key,
    required this.iconName,
    required this.label,
    required this.onPressed,
  });

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: onPressed,
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Image.asset(
            "assets/images/$iconName.png",
            width: 40,
            height: 40,
          ),
          const SizedBox(
            height: 10,
          ), // 图标
          Text(
            label,
            style: const TextStyle(color: ColorConstant.color33, fontSize: 10),
          ), // 文字
        ],
      ),
    );
  }
}

// 上下滚动的消息轮播
class MarqueeWidget extends StatefulWidget {
  /// 子视图数量
  final int count;

  ///子视图构建器
  final IndexedWidgetBuilder itemBuilder;

  ///轮播的时间间隔
  final int loopSeconds;

  const MarqueeWidget({
    super.key,
    required this.count,
    required this.itemBuilder,
    this.loopSeconds = 5,
  });

  @override
  _MarqueeWidgetState createState() => _MarqueeWidgetState();
}

class _MarqueeWidgetState extends State<MarqueeWidget> {
  late PageController _controller;
  late Timer _timer;

  @override
  void initState() {
    super.initState();
    _controller = PageController();
    _timer = Timer.periodic(Duration(seconds: widget.loopSeconds), (timer) {
      if (_controller.page != null) {
        // 如果当前位于最后一页，则直接跳转到第一页，两者内容相同，跳转时视觉上无感知
        if (_controller.page!.round() >= widget.count) {
          _controller.jumpToPage(0);
        }
        _controller.nextPage(
            duration: const Duration(seconds: 1), curve: Curves.linear);
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return PageView.builder(
      scrollDirection: Axis.vertical,
      controller: _controller,
      itemBuilder: (buildContext, index) {
        if (index < widget.count) {
          return widget.itemBuilder(buildContext, index);
        } else {
          return widget.itemBuilder(buildContext, 0);
        }
      },
      itemCount: widget.count + 1,
    );
  }

  @override
  void dispose() {
    super.dispose();
    _controller.dispose();
    _timer.cancel();
  }
}

常见有：
Row/Column：水平/垂直排列子项（基于 Flexbox）。
Stack：子 Widget 堆叠（类似 CSS 的绝对定位）。
Expanded/Flexible：在 Row 或 Column 中分配剩余空间。
Container：结合布局、装饰、边距等功能

常见有：
Text：显示文本。
Image：加载本地或网络图片。
Icon：显示图标（需引入 cupertino_icons 或自定义图标库）

常见有：
ListView：垂直/水平滚动列表。
GridView：网格布局滚动视图。
SingleChildScrollView：包裹单个可滚动子组件。

常见有：
ElevatedButton/TextButton：按钮交互。
TextField：文本输入框。
Checkbox/Switch：选择控件。
GestureDetector：自定义手势检测（点击、长按、拖动）。

常见有：
Material Design：MaterialApp、AppBar、FloatingActionButton。
Cupertino（iOS 风格）：CupertinoApp、CupertinoNavigationBar、CupertinoPicker。

常见有：
AnimatedContainer：自动过渡的容器（大小、颜色等属性变化）。
Hero：页面切换共享元素的过渡动画。
AnimatedBuilder：自定义复杂动画。

常见有：
Navigator：管理页面堆栈（push/pop）。
PageView：实现滑动切换页面。
BottomNavigationBar：底部导航栏。

class MyWidget extends StatefulWidget {
  @override
  _MyWidgetState createState() => _MyWidgetState();
}

@override
void initState() {
  super.initState();
  _controller = AnimationController(vsync: this);
  _fetchData(); // 初始化数据
}

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  if (Provider.of<Data>(context).hasChanged) {
    _updateData();
  }
}

@override
void didUpdateWidget(MyWidget oldWidget) {
  super.didUpdateWidget(oldWidget);
  if (oldWidget.color != widget.color) {
    _updateColor(); // 颜色变化时执行逻辑
  }
}

@override
Widget build(BuildContext context) {
  return Container(
    color: widget.color,
    child: Text('Count: $_count'),
  );
}

@override
void dispose() {
  _controller.dispose(); // 销毁动画控制器
  _subscription.cancel(); // 取消事件订阅
  super.dispose();
}

// 旧 Widget 树
Container(color: Colors.red)

// 新 Widget 树
Container(color: Colors.blue)

// Diff 结果：Container 类型相同且无 Key → 复用 Element，更新 RenderObject 颜色

// Element 更新逻辑
Element.updateChild()

Element updateChild(Element child, Widget newWidget, dynamic newSlot) {
  if (newWidget == null) {
    // 移除子节点
    return null;
  }
  if (child != null) {
    if (child.widget == newWidget) {
      // Widget 未变化 → 复用 Element
      return child;
    }
    if (Widget.canUpdate(child.widget, newWidget)) {
      // 更新 Element 配置
      child.update(newWidget);
      return child;
    }
    // 销毁旧 Element，创建新 Element
    deactivateChild(child);
  }
  return inflateWidget(newWidget, newSlot);
}

// RenderObject 布局流程
RenderObject.layout()

void layout(Constraints constraints, { bool parentUsesSize = false }) {
  _constraints = constraints;
  if (_relayoutBoundary != this) {
    markNeedsLayout();
    return;
  }
  performLayout();  // 1. 计算自身尺寸（调用 performLayout） 由子类实现具体布局逻辑
  _needsLayout = false;
  markNeedsPaint(); // 标记需要重绘
}

void paint(PaintingContext context, Offset offset) {
  // 绘制逻辑，如画矩形
  context.canvas.drawRect(rect, paint);
}

void paintChild(RenderObject child, Offset offset) {
  if (child.isRepaintBoundary) {
    // 创建独立 Layer
    stopRecordingIfNeeded();
    child._layer = OffsetLayer();
    appendLayer(child._layer);
  } else {
    child._paintWithContext(this, offset);
  }
}

static bool canUpdate(Widget oldWidget, Widget newWidget) {
  return oldWidget.runtimeType == newWidget.runtimeType
      && oldWidget.key == newWidget.key;
}

const MyWidget(text: 'Hello'); // ✅ 优化
MyWidget(text: 'Hello');      // ❌ 非 const

ListView.builder(
  itemBuilder: (_, index) => ItemWidget(
    key: ValueKey(items[index].id), // 唯一标识
    data: items[index],
  ),
)

// 父组件（仅传递静态数据）
class ParentWidget extends StatelessWidget {
  const ParentWidget({super.key});
  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        const StaticHeader(), // 静态部分
        DynamicContent(data: _data), // 动态部分
      ],
    );
  }
}

SizedBox(
  width: 100,
  height: 50,
  child: Text('Fixed Size'),
)

RepaintBoundary(
  child: MyAnimatedWidget(), // 独立重绘区域
)

class MyPainter extends CustomPainter {
  @override
  bool shouldRepaint(MyPainter old) {
    return old.color != color; // 仅颜色变化时重绘
  }
}

@override
void dispose() {
  _controller.dispose();
  _streamSubscription.cancel();
  super.dispose();
}

struct WTCertificates {
    static let rootCA = WTCertificates.certificate( )
    static func certificate() -> [SecKey] {
        var publicKeyArray:[SecKey] = []
        for resource in ["xxx", "xxxx", "xxxxx"] {// 本地证书名称
            if let filePath = Bundle.main.path(forResource: resource, ofType: "cer"), let data = try? Data(contentsOf: URL(fileURLWithPath: filePath)) as CFData, let certificate = SecCertificateCreateWithData(nil, data),let publicKey = certificate.af.publicKey {
                publicKeyArray.append(publicKey)
            }
        }
        return publicKeyArray
    }
}

var requestManagerSession: Session = {
    if WTCertificates.rootCA.count > 0, verifyCert {
        let certificates: [SecKey] = WTCertificates.rootCA
        let trustPolicy = PublicKeysTrustEvaluator(keys: certificates, performDefaultValidation: false, validateHost: false)
        let manager = ServerTrustManager(evaluators: [
            "xxx.xxx.com": trustPolicy,
            "xx.xx.jftplus.com": trustPolicy,
            "xxx.xx.com": trustPolicy])// base url 如何域名过多，可以子类化 ServerTrustManager，并用自己的自定义实现重写 serverTrustEvaluator(forHost:) 方法
        let configuration = URLSessionConfiguration.af.default
        return Session(configuration: configuration, serverTrustManager: manager)
    }
    return MoyaProvider<ApiManager>.defaultAlamofireSession()
}()

var JKOtherApiManagerProvider = MoyaProvider<JKOtherApiManager>(endpointClosure: endpointMapping, requestClosure: requestTimeoutClosure, session:requestManagerSession, plugins:[RequestAlertPlugin(), networkPlugin])

//1 将证书拖进项目

//2 获取证书路径
NSString *certPath = [[NSBundle mainBundle] pathForResource: @"cetus" ofType:@"cer"];
//3 获取证书data
NSData *certData = [NSData dataWithContentsOfFile:certPath];
//4 创建AFN 中的securityPolicy
AFSecurityPolicy *securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModePublicKey withPinnedCertificates:[[NSSet alloc] initWithObjects:certData,nil]];
//5 这里就可以添加多个server证书
NSSet *dataSet = [[NSSet alloc]initWithObjects:certData, nil];
//6 绑定证书（不止一个证书）
[securityPolicy setPinnedCertificates:dataSet];
//7 是否允许无效证书
securityPolicy.allowInvalidCertificates = YES;
//8 是否需要验证域名
securityPolicy.validatesDomainName = YES;
uploadManager.securityPolicy = securityPolicy;

import Foundation
import enum Result.Result
import Alamofire

//设置请求超时时间
private let requestTimeoutClosure = { (endpoint: Endpoint, done: @escaping MoyaProvider<ApiManager>.RequestResultClosure) in
    do {
        var request = try endpoint.urlRequest()
        request.timeoutInterval = 60
        done(.success(request))
    } catch {
        return
    }
}
let ApiManagerProvider = MoyaProvider<ApiManager>(endpointClosure: endpointMapping, requestClosure: requestTimeoutClosure, plugins:[])

// MARK: 取消所有请求
func cancelAllRequest() {
    WTOtherProvider.manager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
        dataTasks.forEach { $0.cancel() }
        uploadTasks.forEach { $0.cancel() }
        downloadTasks.forEach { $0.cancel() }
    }
    
    WTLoginProvider.manager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
        dataTasks.forEach { $0.cancel() }
        uploadTasks.forEach { $0.cancel() }
        downloadTasks.forEach { $0.cancel() }
    }
    ……
 }

public func endpointMapping<Target: TargetType>(target: Target) -> Endpoint {
    WTDLog("请求连接：\(target.baseURL)\(target.path) \n方法：\(target.method)\n参数：\(String(describing: target.task.self)) ")
    return MoyaProvider.defaultEndpointMapping(for: target)
}

final class RequestAlertPlugin: PluginType {
    
    func prepare(_ request: URLRequest, target: TargetType) -> URLRequest {
        return request
    }
    
    func willSend(_ request: RequestType, target: TargetType) {
        //实现发送请求前需要做的事情
    }
    
    public func didReceive(_ result: Result<Response, MoyaError>, target: TargetType) {

        switch result {
        case .success(let response):
            guard response.statusCode == 200 else {
                if response.statusCode == 401 {
                    if isJumpLogin == false {
                        cancelAllRequest()
                        // 退出登录
                        if let nvc = (WTNavigationManger.Nav as? WTMainViewController) {
                            nvc.login()
                        }
                    }
                }
                return
            }
            var json = try? JSON(data: response.data)
            WTDLog("请求状态码\(json?["status"] ?? "")")
            
            guard let codeString = json?["status"] else {return}
             if codeString == 401 {// 退出登录
                if isJumpLogin == false {
                    cancelAllRequest()
                    if let nvc = (WTNavigationManger.Nav as? WTMainViewController) {
                        nvc.login()
                    }
                }
                break
            }

        case .failure(let error):
            WTDLog(error)
            let myAppdelegate = UIApplication.shared.delegate as! AppDelegate
            myAppdelegate.listenNetwork()
            break
        }
    }
}

struct AuthPlugin: PluginType {
    let token: String
}


enum ApiManager {
}

extension ApiManager: TargetType {
    var headers: [String : String]? {
        var dict = ["ColaLanguage": ("common.isChinese".L() == "YES") ? "CN" : "EN"]
        if let authToken =  WTLoginInfoManger.shareDataSingle.model?.accessToken {
            dict["Authorization"] = authToken
        }
        return dict
    }
    
    var baseURL: URL {
        return URL.init(string: AppURLHOST.MyPublicBaseURL)!
    }
    
    var path: String {
        return ""
    }
    
    var method: Moya.Method {
        return .get
    }
    
    var task: Task {
        return .requestPlain
    }
    
    var validate: Bool {
        return false
    }
    var sampleData: Data {
        return "".data(using: String.Encoding.utf8)!
    }
}
/// 数据 转 模型
extension ObservableType where E == Response {
    public func mapHandyJsonModel<T: HandyJSON>(_ type: T.Type) -> Observable<T> {
        return flatMap { response -> Observable<T> in
            return Observable.just(response.mapHandyJsonModel(T.self))
        }
    }
}
/// 数据 转 模型
extension Response {
    func mapHandyJsonModel<T: HandyJSON>(_ type: T.Type) -> T {
        let jsonString = String.init(data: data, encoding: .utf8)
        if let modelT = JSONDeserializer<T>.deserializeFrom(json: jsonString) {
            return modelT
        }
        return JSONDeserializer<T>.deserializeFrom(json: "{\"msg\":\"\("common.try".L())\"}")!
    }
}

/// 自定义插件
public final class NetworkLoadingPlugin: PluginType {
    public func willSend(_ request: RequestType, target: TargetType) {
    }
    public func didReceive(_ result: Result<Moya.Response, MoyaError>, target: TargetType) {
    }
}

enum HomeApiManager {
    case getBanner // 获取轮播
    case getAnnouncement(per_page: String) // 获取公告
}

var method: Moya.Method {
        switch self {
        case .orderCreate:
            return .post
        case .orderCancelById, .orderCancelByPair:
            return .delete
        default:
            return .get
        }
    }

var path: String {
        switch self {
        case .getKline:
            return "/api/kline"
        case .transGetByID(let orderId):
            return "/api/\(orderId)"
        }
    }

var task: Task {
    switch self {
    case .securityPostGoogleAuth(let tokenKey, let oldGoogleCode, let googleCode, let captcha):
        return .requestParameters(parameters: ["captcha": captcha], encoding: JSONEncoding.default) // post请求

    case .getReward(let type, let cursor, let limit):
        return .requestParameters(parameters: ["type": type], encoding: URLEncoding.default) // 其它请求

    case .uploadImage(let imageArry):
        let formDataAry:NSMutableArray = NSMutableArray()
        for (index,image) in imageArry.enumerated() {
            //图片转成Data
            let data:Data = image.jpegData(compressionQuality: 0.7)!
            //根据当前时间设置图片上传时候的名字
            var dateStr: String = "yyyy-MM-dd-HH:mm:ss".timeStampToString(timeStamp: Date().timeIntervalSince1970)
            //别忘记这里给名字加上图片的后缀哦
            dateStr = dateStr.appendingFormat("-%i.jpg", index)
            let formData = MultipartFormData(provider: .data(data), name: "file\(index)", fileName: dateStr, mimeType: "image/jpeg")
            formDataAry.add(formData)
        }
        return .uploadCompositeMultipart(formDataAry as! [MultipartFormData], urlParameters: [
            :])
        
    default:
        return .requestPlain
    }
}

final class RequestAlertPlugin: PluginType {
    func prepare(_ request: URLRequest, target: TargetType) -> URLRequest {
        return request
    }
    func willSend(_ request: RequestType, target: TargetType) {
        现发送请求前需要做的事情
        if target.headers?["isHiddentLoading"] != "true" {
            currentView?.addSubview(activityIndicatorView)
            activityIndicatorView.center = currentView!.center
            activityIndicatorView.startAnimating()
        }
    }
    public func didReceive(_ result: Result<Response, MoyaError>, target: TargetType) {
        if activityIndicatorView.isAnimating {
            activityIndicatorView.stopAnimating()
            activityIndicatorView.removeFromSuperview()
        }
    }
}

/// 自定义插件
public final class NetworkLoadingPlugin: PluginType {
    public func willSend(_ request: RequestType, target: TargetType) {
    }
    public func didReceive(_ result: Result<Moya.Response, MoyaError>, target: TargetType) {
    }
}

/// 数据 转 模型
extension ObservableType where E == Response {
    public func mapHandyJsonModel<T: HandyJSON>(_ type: T.Type) -> Observable<T> {
        return flatMap { response -> Observable<T> in
            return Observable.just(response.mapHandyJsonModel(T.self))
        }
    }
}
/// 数据 转 模型
extension Response {
    func mapHandyJsonModel<T: HandyJSON>(_ type: T.Type) -> T {
        let jsonString = String.init(data: data, encoding: .utf8)
        if let modelT = JSONDeserializer<T>.deserializeFrom(json: jsonString) {
            return modelT
        }
        return JSONDeserializer<T>.deserializeFrom(json: "{\"msg\":\"\("common.try".L())\"}")!
    }
}
extension WTApiManager {
    class func NetExchangeRequest<T: BaseModel>(disposeBag: DisposeBag,type: ExchangeApiManager, model: T.Type, isBackFail: Bool = false, Success:@escaping (T)->(), Error: @escaping ()->()) {
        WTExchangeProvider.rx.request(type)
            .asObservable()
            .mapHandyJsonModel(model)
            .subscribe { (event) in
                switch event {
                case let .next(data):
                    if isBackFail {
                        Success(data)
                        break
                    }
                    guard data.status == 200 else {
                        WTProgressHUD.show(error: data.message ?? "common.try".L(), toView: nil)
                        Error()
                        break
                    }
                    Success(data)
                    break
                case let .error(error):
                    WTDLog(error)
                    Error()
                    break
                default:
                    break
                }
            }.disposed(by: disposeBag)
    }
}

class BaseModel: HandyJSON {
    var status: Int = 0
    var message: String? = nil // 服务端返回提示
    required init(){}
}

class WTBaseModel<T: HandyJSON>: BaseModel {
    var data: T? // 具体的data的格式和业务相关，故用泛型定义
}
struct WTCurrencyBalanceModel: HandyJSON {
    var coinCode: String = ""
    let balanceAvailable: Double = 0.0
    let balanceFrozen: Double = 0.0
    let worth: Double = 0.0
}
// 网络请求 传入对应model
WTApiManager.NetOtherRequest(disposeBag: disposeBag, type: .getMarketsPrice, model: WTBaseModel<WTRateModel>, Success: {(model) in
}) {}

lazy var lottieAnimationView: AnimationView = {
        // 加载本地资源
        let path : String = Bundle.main.path(forResource: "data", ofType: "json")!
        let lottieAnimationView = AnimationView.init(filePath: path)
        WTNavigationManger.Nav?.view.addSubview(lottieAnimationView)
        lottieAnimationView.constrain(toSuperviewEdges: nil)
        lottieAnimationView.isUserInteractionEnabled = true
        lottieAnimationView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(removeLottieAnimationViewFromParent)))
        return lottieAnimationView
    }()

// 调用
lottieAnimationView.play {[weak self] (complete) in
       guard let mySelf = self else {return}
       mySelf.removeLottieAnimationViewFromParent()
    }

@objc func removeLottieAnimationViewFromParent() {
        lottieAnimationView.removeFromSuperview()
    }

/// json所在的文件，默认为Bundle.main
let animation = Animation.named("StarAnimation") 
/// 默认为Bundle.main
let animation = Animation.named("StarAnimation", bundle: myBundle)
/// subdirectory 为动画所在的包中的子目录(可选的)
let animation = Animation.named("StarAnimation", subdirectory: "Animations")
/// animationCache 为保存加载动画的缓存(可选的)
let animation = Animation.named("StarAnimation", animationCache: LRUAnimationCache.sharedCache)

Animation.filepath(_ filepath: String, animationCache: AnimationCacheProvider?) -> Animation?

// 播放动画从它的当前状态到它的时间轴结束。在动画停止时调用completion代码块
// 如果动画完成，则completion返回true。如果动画被中断，则返回false
AnimationView.play(completion: LottieCompletionBlock?)

// 指定一个时间到另一个时间的播放
AnimationView.play(fromProgress: AnimationProgressTime?, toProgress: AnimationProgressTime, loopMode: LottieLoopMode?, completion: LottieCompletionBlock?)

// 动画播放从一个时间帧到另一个时间帧
AnimationView.play(fromFrame: AnimationProgressTime?, toFrame: AnimationFrameTime, loopMode: LottieLoopMode?, completion: LottieCompletionBlock?)

// 将动画从命名标记播放到另一个标记。标记是编码到动画数据中并指定名称的时间点
AnimationView.play(fromMarker: String?, toMarker: String, loopMode: LottieLoopMode?, completion: LottieCompletionBlock?)

import UIKit
import Reachability
import Starscream
import zlib

let reachability = Reachability()! // 判断网络连接
let webSocket = WTWebsocket.shared
var reConnectTime = 0 // 设置重连次数
let reConnectMaxTime = 1000 // 设置最大重连次数
let reConnectIntervalTime: TimeInterval = 15 // 设置重连时间间隔(秒)
var websocketTimer: Timer? = nil
var reConnectSubscribeDict:[String : Any] = [:]
var page = "home"
var isReconnect = true

final class WTWebsocket: NSObject,WebSocketDelegate {
    
    var isPingBack = true
    var myWebsocket: WebSocket? = nil
    //  socket连接上函数
    func websocketDidConnect(socket: WebSocketClient) {
        //设置重连次数，解决无限重连问题
        reConnectTime = 0
        if reConnectSubscribeDict.count > 0 {
            self.subscribe(subscribeDict: reConnectSubscribeDict)
        }
        self.hearJump()
        if  websocketTimer == nil {
            websocketTimer = Timer.scheduledTimer(timeInterval: reConnectIntervalTime, target: self, selector: #selector(sendBrandStr), userInfo: nil, repeats: true)
        }
        isReconnect = true
    }
    
    //发送文字消息
    @objc func sendBrandStr(){
        self.checkPing()
        let json = getJSONStringFromDictionary(dictionary: ["topic":"PING"])
        SingletonSocket.sharedInstance.socket.write(string: json)
    }
    
    // 发送ping
    func hearJump() {
        let json = getJSONStringFromDictionary(dictionary: ["topic":"PING"])
        SingletonSocket.sharedInstance.socket.write(string: json)
    }
    
    //  socket断开执行函数
    func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
        //执行重新连接方法
        socketReconnect()
    }
    
    //  接收返回消息函数
    func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
    }
    
    func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
        guard let newStr = String(data: data.gzipUncompress(), encoding: .utf8) else {return}
        if newStr == "PONG" {
            isPingBack = true
            return
        }
      // 处理收到的信息
    }
    
    // 添加注册
    func subscribe(subscribeDict: [String : Any]) {
        var subscribeDicts = subscribeDict
        reConnectSubscribeDict = subscribeDicts
        page = subscribeDicts["type"] as! String
        subscribeDicts.removeValue(forKey: "type")
        let json = getJSONStringFromDictionary(dictionary:
            subscribeDicts as NSDictionary)
        SingletonSocket.sharedInstance.socket.write(string: json)
    }
    
    //检测
    @objc func checkPing() {
        if !isPingBack {
            // 重新连接
            socketReconnect()
        }else {
            isPingBack = false
        }
    }
    //构造单例数据
    static let shared = WTWebsocket()
    private override init() {
    }
}

//socket 重连逻辑
func socketReconnect() {
    //判断网络情况，如果网络正常，可以执行重连
    if reachability.connection != .none {
        //设置重连次数，解决无限重连问题
        reConnectTime =  reConnectTime + 1
        if reConnectTime < reConnectMaxTime {
            //添加重连延时执行，防止某个时间段，全部执行
            let time: TimeInterval = 2.0
            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + time) {
                SingletonSocket.sharedInstance.socket.connect()
                SingletonSocket.sharedInstance.socket.disconnect()
            }
        } else {
            //提示重连失败
        }
    } else {
        //提示无网络
    }
}

//socket主动断开，放在app进入后台时，数据进入缓存。app再进入前台，app出现卡死的情况
func socketDisConnect() {
    if !SingletonSocket.sharedInstance.socket.isConnected {
        websocketTimer?.invalidate()
        websocketTimer = nil
        SingletonSocket.sharedInstance.socket.disconnect()
    }
}

// initSocket方法
func initWebSocketSingle () {
    SingletonSocket.sharedInstance.socket.delegate = webSocket
}

//声明webSocket单例
class SingletonSocket {
    let socket:WebSocket = WebSocket(url: URL(string: AppURLHOST.SocketURL)!)
    class var sharedInstance : SingletonSocket{
        struct Static{
            static let instance:SingletonSocket = SingletonSocket()
        }
        if !Static.instance.socket.isConnected{
            Static.instance.socket.connect()
        }
        return Static.instance
    }
}

func applicationWillResignActive(_ application: UIApplication) {
        //进入后台模式，主动断开socket，防止出现处理不了的情况
        if SingletonSocket.sharedInstance.socket.isConnected {
            reConnectTime = reConnectMaxTime
            socketDisConnect()
        }
    }
    func applicationDidBecomeActive(_ application: UIApplication) {
        //进入前台模式，主动连接socket
        //解决因为网络切换或链接不稳定问题，引起socket断连问题
        //如果app从无网络，到回复网络，需要执行重连
        if !isFirstApplicationDidBecomeActive {
            reConnectTime = 0
            socketReconnect()
            WTBasicConfigManager.shareDataSingle.getHash()
        }
        isFirstApplicationDidBecomeActive = false
    }

[[RCIM sharedRCIM] setUserInfoDataSource:self]; 

- (void)getUserInfoWithUserId:(NSString *)userId completion:(void (^)(RCUserInfo *))completion {
    NSLog(@"getUserInfoWithUserId ----- %@", userId);
    RCUserInfo *user = [RCUserInfo new];
    if (userId == nil || [userId length] == 0) {
        user.userId = userId;
        user.portraitUri = @"";
        user.name = @"";
        completion(user);
        return;
    }
    
    if ([userId isEqualToString:[UserInfo shareInstance].uid]) {
        NSString *urlSelf = [BASIC_URL_image stringByAppendingString:[UserInfo shareInstance].photo];
        return completion([[RCUserInfo alloc] initWithUserId:userId name:[UserInfo shareInstance].nickname portrait:urlSelf]);
    }else {
    
  //根据存储联系人信息的模型，通过 userId 来取得对应的name和头像url，进行以下设置
    [WTBaseHttpRequst postRequstWithURL:getUserHttp params:@{@"uid":[UserInfo shareInstance].uid, @"api_token":[UserInfo shareInstance].api_token, @"k_uid":userId} successBlock:^(NSDictionary *returnData) {
        if ([returnData[@"status"] integerValue] == 1) {
            NSString *urlStr = [BASIC_URL_image stringByAppendingString:returnData[@"data"][@"user"][@"photo"]];
            return completion([[RCUserInfo alloc] initWithUserId:userId name:returnData[@"data"][@"user"][@"nickname"] portrait:urlStr]);
        }else {
            completion(user);
        }
    } failureBlock:^(NSString *error) {
        completion(user);
    } showHUD:NO];
}
}

[[RCIM sharedRCIM] refreshUserInfoCache:user withUserId:[UserInfo shareInstance].uid]

WS(weakSelf);
// 修改用户信息调用
[WTBaseHttpRequst postRequstWithURL:modifyInfoHttp params:dict successBlock:^(NSDictionary *returnData) {
    [weakSelf MBProgressHudShowWithTextOnlyWithText:returnData[@"msg"]];
    if ([returnData[@"status"] integerValue] == 1) {
        RCUserInfo *user = [RCUserInfo new];
        user.userId = [UserInfo shareInstance].uid;
        user.portraitUri = [BASIC_URL_image stringByAppendingString:[UserInfo shareInstance].photo];
        user.name = weakSelf.nickNameTextField.text;
        [[RCIM sharedRCIM] refreshUserInfoCache:user withUserId:[UserInfo shareInstance].uid];
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            [self.navigationController popViewControllerAnimated:YES];
        });
    }
} failureBlock:^(NSString *error) {
    [weakSelf MBProgressHudShowWithTextOnlyWithText:error];
} showHUD:YES];

[RCIM sharedRCIM].enableMessageAttachUserInfo = YES; 
```  
  
**你设置了enableMessageAttachUserInfo之后，可以取到**

### 在会话列表中添加一些固定的cell(继承RCConversationListViewController)

let searchFiled:UITextField = self.searchBar.value(forKey: "_searchField") as! UITextField

class MySearchBar: UISearchBar {
    
    // 监听是否添加了该属性
    var contentInset: UIEdgeInsets? {
        didSet {
            self.layoutSubviews()
        }
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        // 便利寻找
        for view in self.subviews {
            for subview in view.subviews {
                // 判定是否是UISearchBarTextField
                if subview.isKind(of: UITextField.classForCoder()) {
                    if let textFieldContentInset = contentInset {
                        // 修改UISearchBarTextField的布局
                        subview.frame = CGRect(x: textFieldContentInset.left, y: textFieldContentInset.top, width: self.bounds.width - textFieldContentInset.left - textFieldContentInset.right, height: self.bounds.height - textFieldContentInset.top - textFieldContentInset.bottom)
                    } else {
                        // 设置UISearchBar中UISearchBarTextField的默认边距
                        let top: CGFloat = (self.bounds.height - 28.0) / 2.0
                        let bottom: CGFloat = top
                        let left: CGFloat = 8.0
                        let right: CGFloat = left
                        contentInset = UIEdgeInsets(top: top, left: left, bottom: bottom, right: right)
                    }
                }
            }
        }
    }

}

self.searchBar.contentInset = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 0)

if SCREEN.WIDTH == 320 {
           self.searchBar.placeholder = "搜索位置       "
       }else if SCREEN.WIDTH == 373\5 {
           self.searchBar.placeholder = "搜索位置                  "
       }else if SCREEN.WIDTH == 414 {
           self.searchBar.placeholder = "搜索位置                                 "
       }

self.searchBar.setBackgroundImage(UIImage.init(), for: .any, barMetrics: .default)

- (BOOL)searchBar:(UISearchBar *)searchBar shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)textNS_AVAILABLE_IOS(3_0);                 // called before text changes

- (void)searchBarSearchButtonClicked:(UISearchBar *)searchBar;