Struct NestedScrollView 

pub struct NestedScrollView { /* private fields */ }

A NestedScrollView provides scrolling capability

Implementations

impl NestedScrollView

pub fn new(activity: &mut Activity, parent: Option<i64>) -> Result<Self>

Create a new NestedScrollView

pub fn id(&self) -> i64

Get the view ID

Examples found in repository

examples/image_demo_v2.rs (line 19)

fn main() -> Result<()> {
    println!("=== ImageView 图像显示演示 (新库版本) ===\n");
    
    // 创建 Activity（全屏模式）
    let mut activity = Activity::new(false)?;
    println!("✓ 连接建立\n");
    
    // 创建 NestedScrollView 作为根布局（支持滚动）
    let scroll = activity.create_nested_scroll_view(None)?;
    
    // 创建主布局（放在 ScrollView 内）
    let layout = activity.create_linear_layout(Some(scroll.id()))?;
    layout.view().set_margin(&mut activity, 15)?;
    
    // 创建标题
    let title = activity.create_text_view("🖼️ 图片显示测试", Some(layout.id()))?;
    title.set_text_size(&mut activity, 26)?;
    title.view().set_margin(&mut activity, 10)?;
    title.view().set_height_wrap_content(&mut activity)?;
    title.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建说明
    let desc = activity.create_text_view("显示一个小的测试图片", Some(layout.id()))?;
    desc.view().set_margin(&mut activity, 5)?;
    desc.view().set_height_wrap_content(&mut activity)?;
    desc.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建 ImageView
    let image_view = activity.create_image_view(Some(layout.id()))?;
    image_view.view().set_margin(&mut activity, 10)?;
    // ImageView 使用权重占据主要空间
    image_view.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    // 创建一个简单的 1x1 红色像素 PNG 图片（base64编码）
    // 这是一个最小的有效PNG文件
    let red_pixel_png_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==";
    
    // 设置图片
    image_view.set_image(&mut activity, red_pixel_png_base64)?;
    
    // 创建状态显示
    let status = activity.create_text_view("✅ 图片已加载", Some(layout.id()))?;
    status.view().set_margin(&mut activity, 10)?;
    status.view().set_height_wrap_content(&mut activity)?;
    status.view().set_linear_layout_params(&mut activity, 0, None)?;
    status.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
    
    // 创建按钮布局
    let button_layout = activity.create_linear_layout_horizontal(Some(layout.id()))?;
    button_layout.view().set_margin(&mut activity, 10)?;
    button_layout.view().set_height_wrap_content(&mut activity)?;
    button_layout.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 红色图片按钮
    let red_btn = activity.create_button("🔴 红色", Some(button_layout.id()))?;
    red_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    // 绿色图片按钮
    let green_btn = activity.create_button("🟢 绿色", Some(button_layout.id()))?;
    green_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    // 蓝色图片按钮
    let blue_btn = activity.create_button("🔵 蓝色", Some(button_layout.id()))?;
    blue_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    println!("✓ 界面创建完成\n");
    println!("━━━━━━━━━━━━━━━━━━━━━━");
    println!("提示:");
    println!("  • 点击按钮切换不同颜色的图片");
    println!("  • 图片会自动缩放填充区域");
    println!("━━━━━━━━━━━━━━━━━━━━━━\n");
    
    // 预定义几个不同颜色的1x1像素PNG图片（base64）
    // 红色像素
    let red_png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg==";
    // 绿色像素
    let green_png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M/wHwAEBgIApD5fRAAAAABJRU5ErkJggg==";
    // 蓝色像素
    let blue_png = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPj/HwADBwIAMCbHYQAAAABJRU5ErkJggg==";
    
    // 事件循环
    loop {
        let event = read_message(activity.event_stream())?;
        let event_type = event["type"].as_str().unwrap_or("");
        let event_value = &event["value"];
        
        match event_type {
            "destroy" => {
                // Activity 已被系统销毁，直接退出即可
                println!("\n✓ Activity 已关闭");
                return Ok(());
            },
            "click" => {
                let clicked_id = event_value["id"].as_i64().unwrap_or(-1);
                
                if clicked_id == red_btn.id() {
                    println!("🔴 切换到红色图片");
                    image_view.set_image(&mut activity, red_png)?;
                    status.set_text(&mut activity, "🔴 红色图片")?;
                    status.set_text_color(&mut activity, 0xFFF44336u32 as i32)?;
                } else if clicked_id == green_btn.id() {
                    println!("🟢 切换到绿色图片");
                    image_view.set_image(&mut activity, green_png)?;
                    status.set_text(&mut activity, "🟢 绿色图片")?;
                    status.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                } else if clicked_id == blue_btn.id() {
                    println!("🔵 切换到蓝色图片");
                    image_view.set_image(&mut activity, blue_png)?;
                    status.set_text(&mut activity, "🔵 蓝色图片")?;
                    status.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
                }
            },
            _ => {}
        }
    }
}

examples/grid_layout_demo_v2.rs (line 19)

fn main() -> Result<()> {
    println!("=== GridLayout 网格布局演示 (新库版本) ===\n");
    
    // 创建 Activity（全屏模式）
    let mut activity = Activity::new(false)?;
    println!("✓ 连接建立\n");
    
    // 创建 NestedScrollView 作为根布局（支持滚动）
    let scroll = activity.create_nested_scroll_view(None)?;
    
    // 创建主布局（放在 ScrollView 内）
    let layout = activity.create_linear_layout(Some(scroll.id()))?;
    layout.view().set_margin(&mut activity, 15)?;
    
    // 创建标题
    let title = activity.create_text_view("🎯 GridLayout 演示", Some(layout.id()))?;
    title.set_text_size(&mut activity, 26)?;
    title.view().set_margin(&mut activity, 10)?;
    title.view().set_height_wrap_content(&mut activity)?;
    title.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建说明
    let desc = activity.create_text_view("网格布局：行列自动排列", Some(layout.id()))?;
    desc.view().set_margin(&mut activity, 5)?;
    desc.view().set_height_wrap_content(&mut activity)?;
    desc.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // ========== 示例1: 3x3 按钮网格 ==========
    let section1 = activity.create_text_view("示例1: 3×3 按钮网格", Some(layout.id()))?;
    section1.set_text_size(&mut activity, 18)?;
    section1.view().set_margin(&mut activity, 10)?;
    section1.view().set_height_wrap_content(&mut activity)?;
    section1.view().set_linear_layout_params(&mut activity, 0, None)?;
    section1.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
    
    // 创建 3x3 GridLayout
    let grid1 = activity.create_grid_layout(3, 3, Some(layout.id()))?;
    grid1.view().set_margin(&mut activity, 10)?;
    grid1.view().set_width_match_parent(&mut activity)?;
    grid1.view().set_height_wrap_content(&mut activity)?;
    grid1.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建9个按钮（自动填充到3x3网格）
    let mut grid1_buttons = Vec::new();
    for i in 1..=9 {
        let btn = activity.create_button(&format!("{}", i), Some(grid1.id()))?;
        grid1_buttons.push(btn);
    }
    
    // ========== 示例2: 2x4 文本网格 ==========
    let divider1 = activity.create_text_view("━━━━━━━━━━━━━━━━━━━━", Some(layout.id()))?;
    divider1.view().set_margin(&mut activity, 10)?;
    divider1.view().set_height_wrap_content(&mut activity)?;
    divider1.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let section2 = activity.create_text_view("示例2: 2×4 表情网格", Some(layout.id()))?;
    section2.set_text_size(&mut activity, 18)?;
    section2.view().set_margin(&mut activity, 10)?;
    section2.view().set_height_wrap_content(&mut activity)?;
    section2.view().set_linear_layout_params(&mut activity, 0, None)?;
    section2.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
    
    // 创建 2x4 GridLayout
    let grid2 = activity.create_grid_layout(2, 4, Some(layout.id()))?;
    grid2.view().set_margin(&mut activity, 10)?;
    grid2.view().set_width_match_parent(&mut activity)?;
    grid2.view().set_height_wrap_content(&mut activity)?;
    grid2.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 8个表情文本（自动填充到2x4网格）
    let emojis = ["😀", "😎", "🎉", "🚀", "🌟", "❤️", "👍", "🔥"];
    for emoji in &emojis {
        let text = activity.create_text_view(emoji, Some(grid2.id()))?;
        text.set_text_size(&mut activity, 32)?;
        text.view().set_margin(&mut activity, 5)?;
    }
    
    // ========== 示例3: 4x2 混合网格 ==========
    let divider2 = activity.create_text_view("━━━━━━━━━━━━━━━━━━━━", Some(layout.id()))?;
    divider2.view().set_margin(&mut activity, 10)?;
    divider2.view().set_height_wrap_content(&mut activity)?;
    divider2.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let section3 = activity.create_text_view("示例3: 4×2 开关网格", Some(layout.id()))?;
    section3.set_text_size(&mut activity, 18)?;
    section3.view().set_margin(&mut activity, 10)?;
    section3.view().set_height_wrap_content(&mut activity)?;
    section3.view().set_linear_layout_params(&mut activity, 0, None)?;
    section3.set_text_color(&mut activity, 0xFFFF9800u32 as i32)?;
    
    // 创建 4x2 GridLayout
    let grid3 = activity.create_grid_layout(4, 2, Some(layout.id()))?;
    grid3.view().set_margin(&mut activity, 10)?;
    grid3.view().set_width_match_parent(&mut activity)?;
    grid3.view().set_height_wrap_content(&mut activity)?;
    grid3.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 8个 ToggleButton（自动填充到4x2网格）
    let toggle_labels = ["WiFi", "蓝牙", "GPS", "飞行", "数据", "热点", "蓝光", "省电"];
    let mut grid3_toggles = Vec::new();
    for label in &toggle_labels {
        let toggle = activity.create_toggle_button(label, Some(grid3.id()))?;
        grid3_toggles.push(toggle);
    }
    
    // ========== 底部信息 ==========
    let divider3 = activity.create_text_view("━━━━━━━━━━━━━━━━━━━━", Some(layout.id()))?;
    divider3.view().set_margin(&mut activity, 10)?;
    divider3.view().set_height_wrap_content(&mut activity)?;
    divider3.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let info = activity.create_text_view(
        "💡 GridLayout 特点:\n\
        • 指定行数和列数创建网格\n\
        • 子视图按添加顺序自动填充\n\
        • 从左到右、从上到下排列\n\
        • 适合创建规则的网格界面",
        Some(layout.id())
    )?;
    info.view().set_margin(&mut activity, 10)?;
    info.view().set_height_wrap_content(&mut activity)?;
    info.view().set_linear_layout_params(&mut activity, 0, None)?;
    info.set_text_color(&mut activity, 0xFF666666u32 as i32)?;
    
    // 状态显示
    let status = activity.create_text_view("准备就绪 - 点击任意元素试试", Some(layout.id()))?;
    status.view().set_margin(&mut activity, 10)?;
    status.view().set_height_wrap_content(&mut activity)?;
    status.view().set_linear_layout_params(&mut activity, 0, None)?;
    status.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
    
    println!("✓ 界面创建完成\n");
    println!("━━━━━━━━━━━━━━━━━━━━━━");
    println!("提示:");
    println!("  • 观察三个不同尺寸的网格布局");
    println!("  • 3×3 按钮网格：数字1-9");
    println!("  • 2×4 表情网格：8个表情");
    println!("  • 4×2 开关网格：8个ToggleButton");
    println!("━━━━━━━━━━━━━━━━━━━━━━\n");
    
    // 事件循环
    loop {
        let event = read_message(activity.event_stream())?;
        let event_type = event["type"].as_str().unwrap_or("");
        let event_value = &event["value"];
        
        match event_type {
            "destroy" => {
                // Activity 已被系统销毁，直接退出即可
                println!("\n✓ Activity 已关闭");
                return Ok(());
            },
            "click" => {
                let clicked_id = event_value["id"].as_i64().unwrap_or(-1);
                
                // 检查是否是第一个网格的按钮
                for (i, btn) in grid1_buttons.iter().enumerate() {
                    if clicked_id == btn.id() {
                        println!("✅ 点击了数字按钮: {}", i + 1);
                        status.set_text(&mut activity, &format!("✅ 点击了数字: {}", i + 1))?;
                        status.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                        break;
                    }
                }
                
                // 检查是否是第三个网格的开关
                for (i, toggle) in grid3_toggles.iter().enumerate() {
                    if clicked_id == toggle.id() {
                        let is_checked = event_value["set"].as_bool().unwrap_or(false);
                        println!("🔘 {}: {}", toggle_labels[i], if is_checked { "开启" } else { "关闭" });
                        status.set_text(&mut activity, 
                            &format!("🔘 {}: {}", toggle_labels[i], if is_checked { "开启" } else { "关闭" }))?;
                        status.set_text_color(&mut activity, 
                            if is_checked { 0xFFFF9800u32 as i32 } else { 0xFF9E9E9Eu32 as i32 })?;
                        break;
                    }
                }
            },
            _ => {}
        }
    }
}

examples/progress_demo_v2.rs (line 21)

fn main() -> Result<()> {
    println!("=== ProgressBar 进度条演示 (新库版本) ===\n");
    
    // 创建 Activity（全屏模式）
    let mut activity = Activity::new(false)?;
    println!("✓ 连接建立\n");
    
    // 创建 NestedScrollView 作为根布局（支持滚动）
    let scroll = activity.create_nested_scroll_view(None)?;
    
    // 创建主布局（放在 ScrollView 内）
    let layout = activity.create_linear_layout(Some(scroll.id()))?;
    layout.view().set_margin(&mut activity, 15)?;
    
    // 创建标题
    let title = activity.create_text_view("📊 进度条演示", Some(layout.id()))?;
    title.set_text_size(&mut activity, 26)?;
    title.view().set_margin(&mut activity, 10)?;
    title.view().set_height_wrap_content(&mut activity)?;
    title.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建说明
    let desc = activity.create_text_view("点击按钮控制进度", Some(layout.id()))?;
    desc.view().set_margin(&mut activity, 5)?;
    desc.view().set_height_wrap_content(&mut activity)?;
    desc.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建 ProgressBar 1 - 主进度条
    let label1 = activity.create_text_view("主任务进度:", Some(layout.id()))?;
    label1.view().set_margin(&mut activity, 10)?;
    label1.view().set_height_wrap_content(&mut activity)?;
    label1.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let progress1 = activity.create_progress_bar(Some(layout.id()))?;
    progress1.view().set_margin(&mut activity, 10)?;
    progress1.view().set_width_match_parent(&mut activity)?;
    progress1.view().set_height_wrap_content(&mut activity)?;
    progress1.view().set_linear_layout_params(&mut activity, 0, None)?;
    progress1.set_progress(&mut activity, 0)?;
    
    let progress1_text = activity.create_text_view("0%", Some(layout.id()))?;
    progress1_text.view().set_margin(&mut activity, 5)?;
    progress1_text.view().set_height_wrap_content(&mut activity)?;
    progress1_text.view().set_linear_layout_params(&mut activity, 0, None)?;
    progress1_text.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
    
    // 创建 ProgressBar 2 - 次要进度条
    let label2 = activity.create_text_view("下载进度:", Some(layout.id()))?;
    label2.view().set_margin(&mut activity, 10)?;
    label2.view().set_height_wrap_content(&mut activity)?;
    label2.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let progress2 = activity.create_progress_bar(Some(layout.id()))?;
    progress2.view().set_margin(&mut activity, 10)?;
    progress2.view().set_width_match_parent(&mut activity)?;
    progress2.view().set_height_wrap_content(&mut activity)?;
    progress2.view().set_linear_layout_params(&mut activity, 0, None)?;
    progress2.set_progress(&mut activity, 0)?;
    
    let progress2_text = activity.create_text_view("0%", Some(layout.id()))?;
    progress2_text.view().set_margin(&mut activity, 5)?;
    progress2_text.view().set_height_wrap_content(&mut activity)?;
    progress2_text.view().set_linear_layout_params(&mut activity, 0, None)?;
    progress2_text.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
    
    // 创建分隔线
    let divider = activity.create_text_view("━━━━━━━━━━━━━━━━━━━━", Some(layout.id()))?;
    divider.view().set_margin(&mut activity, 10)?;
    divider.view().set_height_wrap_content(&mut activity)?;
    divider.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // 创建按钮布局
    let button_layout1 = activity.create_linear_layout_horizontal(Some(layout.id()))?;
    button_layout1.view().set_margin(&mut activity, 10)?;
    button_layout1.view().set_height_wrap_content(&mut activity)?;
    button_layout1.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let inc_btn = activity.create_button("➕ 增加", Some(button_layout1.id()))?;
    inc_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    let dec_btn = activity.create_button("➖ 减少", Some(button_layout1.id()))?;
    dec_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    let reset_btn = activity.create_button("🔄 重置", Some(button_layout1.id()))?;
    reset_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    // 第二行按钮
    let button_layout2 = activity.create_linear_layout_horizontal(Some(layout.id()))?;
    button_layout2.view().set_margin(&mut activity, 10)?;
    button_layout2.view().set_height_wrap_content(&mut activity)?;
    button_layout2.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let auto_btn = activity.create_button("▶️ 自动演示", Some(button_layout2.id()))?;
    auto_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    let complete_btn = activity.create_button("✅ 完成", Some(button_layout2.id()))?;
    complete_btn.view().set_linear_layout_params(&mut activity, 1, None)?;
    
    println!("✓ 界面创建完成\n");
    println!("━━━━━━━━━━━━━━━━━━━━━━");
    println!("提示:");
    println!("  • ➕ 增加 - 进度 +10%");
    println!("  • ➖ 减少 - 进度 -10%");
    println!("  • 🔄 重置 - 进度归零");
    println!("  • ▶️ 自动演示 - 模拟加载过程");
    println!("  • ✅ 完成 - 进度设为100%");
    println!("━━━━━━━━━━━━━━━━━━━━━━\n");
    
    // 进度状态
    let mut progress1_value = 0;
    let mut progress2_value = 0;
    
    // 事件循环
    loop {
        let event = read_message(activity.event_stream())?;
        let event_type = event["type"].as_str().unwrap_or("");
        let event_value = &event["value"];
        
        match event_type {
            "destroy" => {
                // Activity 已被系统销毁，直接退出即可
                println!("\n✓ Activity 已关闭");
                return Ok(());
            },
            "click" => {
                let clicked_id = event_value["id"].as_i64().unwrap_or(-1);
                
                if clicked_id == inc_btn.id() {
                    // 增加进度
                    progress1_value = (progress1_value + 10).min(100);
                    progress1.set_progress(&mut activity, progress1_value)?;
                    progress1_text.set_text(&mut activity, &format!("{}%", progress1_value))?;
                    println!("➕ 进度: {}%", progress1_value);
                    
                } else if clicked_id == dec_btn.id() {
                    // 减少进度
                    progress1_value = (progress1_value - 10).max(0);
                    progress1.set_progress(&mut activity, progress1_value)?;
                    progress1_text.set_text(&mut activity, &format!("{}%", progress1_value))?;
                    println!("➖ 进度: {}%", progress1_value);
                    
                } else if clicked_id == reset_btn.id() {
                    // 重置
                    progress1_value = 0;
                    progress2_value = 0;
                    progress1.set_progress(&mut activity, 0)?;
                    progress2.set_progress(&mut activity, 0)?;
                    progress1_text.set_text(&mut activity, "0%")?;
                    progress2_text.set_text(&mut activity, "0%")?;
                    progress1_text.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
                    progress2_text.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
                    println!("🔄 进度已重置");
                    
                } else if clicked_id == complete_btn.id() {
                    // 完成
                    progress1_value = 100;
                    progress2_value = 100;
                    progress1.set_progress(&mut activity, 100)?;
                    progress2.set_progress(&mut activity, 100)?;
                    progress1_text.set_text(&mut activity, "100% ✓")?;
                    progress2_text.set_text(&mut activity, "100% ✓")?;
                    progress1_text.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                    progress2_text.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                    println!("✅ 任务完成！");
                    
                } else if clicked_id == auto_btn.id() {
                    // 自动演示 - 模拟加载过程
                    println!("▶️ 开始自动演示...");
                    progress1_value = 0;
                    progress2_value = 0;
                    
                    // 模拟两个进度条同时加载
                    for i in 0..=10 {
                        progress1_value = i * 10;
                        progress2_value = i * 10;
                        
                        progress1.set_progress(&mut activity, progress1_value)?;
                        progress2.set_progress(&mut activity, progress2_value)?;
                        
                        progress1_text.set_text(&mut activity, &format!("{}%", progress1_value))?;
                        progress2_text.set_text(&mut activity, &format!("{}%", progress2_value))?;
                        
                        if i == 10 {
                            progress1_text.set_text(&mut activity, "100% ✓")?;
                            progress2_text.set_text(&mut activity, "100% ✓")?;
                            progress1_text.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                            progress2_text.set_text_color(&mut activity, 0xFF4CAF50u32 as i32)?;
                        }
                        
                        println!("   进度: {}%", progress1_value);
                        
                        // 延迟一下，让用户看到进度变化
                        thread::sleep(Duration::from_millis(300));
                    }
                    
                    println!("✅ 自动演示完成！");
                }
            },
            _ => {}
        }
    }
}

examples/spinner_demo_v2.rs (line 19)

fn main() -> Result<()> {
    println!("=== Spinner 下拉列表演示 (新库版本) ===\n");
    
    // 创建 Activity（全屏模式）
    let mut activity = Activity::new(false)?;
    println!("✓ 连接建立\n");
    
    // 创建 NestedScrollView 作为根布局（支持滚动）
    let scroll = activity.create_nested_scroll_view(None)?;
    
    // 创建主布局（放在 ScrollView 内）
    let layout = activity.create_linear_layout(Some(scroll.id()))?;
    layout.view().set_margin(&mut activity, 20)?;
    
    // 标题
    let title = activity.create_text_view("📱 手机订购向导", Some(layout.id()))?;
    title.set_text_size(&mut activity, 24)?;
    title.view().set_height_wrap_content(&mut activity)?;
    title.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // ========== 品牌选择 ==========
    let brand_label = activity.create_text_view("选择品牌:", Some(layout.id()))?;
    brand_label.set_text_size(&mut activity, 18)?;
    brand_label.view().set_margin(&mut activity, 10)?;
    brand_label.view().set_height_wrap_content(&mut activity)?;
    brand_label.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let brands = vec!["请选择", "Apple", "Samsung", "Huawei", "Xiaomi", "OPPO", "Vivo"];
    let brand_spinner = activity.create_spinner(Some(layout.id()))?;
    brand_spinner.view().set_width_match_parent(&mut activity)?;
    brand_spinner.view().set_height_wrap_content(&mut activity)?;
    brand_spinner.view().set_linear_layout_params(&mut activity, 0, None)?;
    brand_spinner.set_list(&mut activity, &brands)?;
    brand_spinner.refresh(&mut activity)?;
    
    // ========== 型号选择 ==========
    let model_label = activity.create_text_view("选择型号:", Some(layout.id()))?;
    model_label.set_text_size(&mut activity, 18)?;
    model_label.view().set_margin(&mut activity, 10)?;
    model_label.view().set_height_wrap_content(&mut activity)?;
    model_label.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let model_spinner = activity.create_spinner(Some(layout.id()))?;
    model_spinner.view().set_width_match_parent(&mut activity)?;
    model_spinner.view().set_height_wrap_content(&mut activity)?;
    model_spinner.view().set_linear_layout_params(&mut activity, 0, None)?;
    model_spinner.set_list(&mut activity, &["请先选择品牌"])?;
    model_spinner.refresh(&mut activity)?;
    
    // ========== 容量选择 ==========
    let storage_label = activity.create_text_view("选择容量:", Some(layout.id()))?;
    storage_label.set_text_size(&mut activity, 18)?;
    storage_label.view().set_margin(&mut activity, 10)?;
    storage_label.view().set_height_wrap_content(&mut activity)?;
    storage_label.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let storages = vec!["请选择", "64GB", "128GB", "256GB", "512GB", "1TB"];
    let storage_spinner = activity.create_spinner(Some(layout.id()))?;
    storage_spinner.view().set_width_match_parent(&mut activity)?;
    storage_spinner.view().set_height_wrap_content(&mut activity)?;
    storage_spinner.view().set_linear_layout_params(&mut activity, 0, None)?;
    storage_spinner.set_list(&mut activity, &storages)?;
    storage_spinner.refresh(&mut activity)?;
    
    // ========== 颜色选择 ==========
    let color_label = activity.create_text_view("选择颜色:", Some(layout.id()))?;
    color_label.set_text_size(&mut activity, 18)?;
    color_label.view().set_margin(&mut activity, 10)?;
    color_label.view().set_height_wrap_content(&mut activity)?;
    color_label.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    let colors = vec!["请选择", "黑色", "白色", "金色", "银色", "蓝色", "紫色", "绿色"];
    let color_spinner = activity.create_spinner(Some(layout.id()))?;
    color_spinner.view().set_width_match_parent(&mut activity)?;
    color_spinner.view().set_height_wrap_content(&mut activity)?;
    color_spinner.view().set_linear_layout_params(&mut activity, 0, None)?;
    color_spinner.set_list(&mut activity, &colors)?;
    color_spinner.refresh(&mut activity)?;
    
    // ========== 结果显示 ==========
    let result = activity.create_text_view("请完成选择", Some(layout.id()))?;
    result.set_text_size(&mut activity, 16)?;
    result.set_text_color(&mut activity, 0xFF666666u32 as i32)?;
    result.view().set_margin(&mut activity, 10)?;
    result.view().set_height_wrap_content(&mut activity)?;
    result.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    // ========== 提交按钮 ==========
    let submit_btn = activity.create_button("🛒 确认订购", Some(layout.id()))?;
    submit_btn.view().set_margin(&mut activity, 10)?;
    submit_btn.view().set_height_wrap_content(&mut activity)?;
    submit_btn.view().set_linear_layout_params(&mut activity, 0, None)?;
    
    println!("✓ 界面创建完成\n");
    println!("━━━━━━━━━━━━━━━━━━━━━━");
    println!("提示: 从下拉列表中选择");
    println!("━━━━━━━━━━━━━━━━━━━━━━\n");
    
    // 选择状态
    let mut brand_selection = String::new();
    let mut model_selection = String::new();
    let mut storage_selection = String::new();
    let mut color_selection = String::new();
    
    // 更新结果显示的辅助函数
    let update_result = |activity: &mut Activity, 
                         result: &TextView,
                         brand: &str, 
                         model: &str, 
                         storage: &str, 
                         color: &str| -> Result<()> {
        let all_selected = !brand.is_empty() && !model.is_empty() 
                          && !storage.is_empty() && !color.is_empty();
        
        let result_text = if all_selected {
            format!("✅ 已选择:\n品牌: {}\n型号: {}\n容量: {}\n颜色: {}",
                    brand, model, storage, color)
        } else {
            let mut missing = Vec::new();
            if brand.is_empty() { missing.push("品牌"); }
            if model.is_empty() { missing.push("型号"); }
            if storage.is_empty() { missing.push("容量"); }
            if color.is_empty() { missing.push("颜色"); }
            format!("⚠️ 待选择: {}", missing.join(", "))
        };
        
        result.set_text(activity, &result_text)?;
        
        let text_color = if all_selected { 
            0xFF4CAF50u32 as i32  // 绿色
        } else { 
            0xFF666666u32 as i32  // 灰色
        };
        result.set_text_color(activity, text_color)?;
        
        Ok(())
    };
    
    // 事件循环
    loop {
        let event = read_message(activity.event_stream())?;
        let event_type = event["type"].as_str().unwrap_or("");
        let event_value = &event["value"];
        
        match event_type {
            "destroy" => {
                // Activity 已被系统销毁，直接退出即可
                println!("\n✓ Activity 已关闭");
                return Ok(());
            },
            "itemselected" => {
                let view_id = event_value["id"].as_i64().unwrap_or(-1);
                let index = event_value["index"].as_i64().unwrap_or(0) as usize;
                
                if view_id == brand_spinner.id() {
                    // 品牌选择
                    if index > 0 && index < brands.len() {
                        let brand = brands[index];
                        brand_selection = brand.to_string();
                        println!("📱 品牌: {}", brand);
                        
                        // 根据品牌更新型号列表
                        let models: Vec<&str> = match brand {
                            "Apple" => vec!["请选择", "iPhone 15 Pro Max", "iPhone 15 Pro", "iPhone 15", "iPhone 14"],
                            "Samsung" => vec!["请选择", "Galaxy S24 Ultra", "Galaxy S24+", "Galaxy S24", "Galaxy Z Fold5"],
                            "Huawei" => vec!["请选择", "Mate 60 Pro", "Mate 60", "P60 Pro", "P60"],
                            "Xiaomi" => vec!["请选择", "14 Ultra", "14 Pro", "14", "13T Pro"],
                            "OPPO" => vec!["请选择", "Find X7 Ultra", "Find X7", "Reno 11 Pro", "Reno 11"],
                            "Vivo" => vec!["请选择", "X100 Pro", "X100", "S18 Pro", "S18"],
                            _ => vec!["请选择"],
                        };
                        
                        // 更新型号 Spinner
                        model_spinner.set_list(&mut activity, &models)?;
                        model_spinner.refresh(&mut activity)?;
                        
                        // 重置型号选择
                        model_selection.clear();
                    } else {
                        brand_selection.clear();
                    }
                } else if view_id == model_spinner.id() {
                    // 型号选择
                    if index > 0 {
                        let models_list: Vec<&str> = match brand_selection.as_str() {
                            "Apple" => vec!["", "iPhone 15 Pro Max", "iPhone 15 Pro", "iPhone 15", "iPhone 14"],
                            "Samsung" => vec!["", "Galaxy S24 Ultra", "Galaxy S24+", "Galaxy S24", "Galaxy Z Fold5"],
                            "Huawei" => vec!["", "Mate 60 Pro", "Mate 60", "P60 Pro", "P60"],
                            "Xiaomi" => vec!["", "14 Ultra", "14 Pro", "14", "13T Pro"],
                            "OPPO" => vec!["", "Find X7 Ultra", "Find X7", "Reno 11 Pro", "Reno 11"],
                            "Vivo" => vec!["", "X100 Pro", "X100", "S18 Pro", "S18"],
                            _ => vec![""],
                        };
                        
                        if index < models_list.len() {
                            let model = models_list[index];
                            model_selection = model.to_string();
                            println!("📱 型号: {}", model);
                        }
                    } else {
                        model_selection.clear();
                    }
                } else if view_id == storage_spinner.id() {
                    // 容量选择
                    if index > 0 && index < storages.len() {
                        let storage = storages[index];
                        storage_selection = storage.to_string();
                        println!("💾 容量: {}", storage);
                    } else {
                        storage_selection.clear();
                    }
                } else if view_id == color_spinner.id() {
                    // 颜色选择
                    if index > 0 && index < colors.len() {
                        let color = colors[index];
                        color_selection = color.to_string();
                        println!("🎨 颜色: {}", color);
                    } else {
                        color_selection.clear();
                    }
                }
                
                // 更新结果显示
                update_result(&mut activity, &result,
                             &brand_selection, &model_selection, 
                             &storage_selection, &color_selection)?;
            },
            "click" => {
                let clicked_id = event_value["id"].as_i64().unwrap_or(-1);
                
                if clicked_id == submit_btn.id() {
                    let all_selected = !brand_selection.is_empty() 
                                     && !model_selection.is_empty()
                                     && !storage_selection.is_empty() 
                                     && !color_selection.is_empty();
                    
                    if all_selected {
                        let order_info = format!(
                            "🎉 订购成功！\n\n品牌: {}\n型号: {}\n容量: {}\n颜色: {}\n\n感谢您的订购！",
                            brand_selection, model_selection, storage_selection, color_selection
                        );
                        
                        println!("\n{}", order_info);
                        
                        result.set_text(&mut activity, &order_info)?;
                        result.set_text_color(&mut activity, 0xFF2196F3u32 as i32)?;
                    } else {
                        println!("⚠️  请完成所有选择！");
                    }
                }
            },
            _ => {}
        }
    }
}

pub fn view(&self) -> &View

Get the underlying View