Wondershare EdrawMind
EdrawMindZongmu API Interface description
MindMap Gallery Zongmu API Interface description
- 42
Zongmu API Interface description
First, API mind maps can help developers better understand the various parts of the API, including request and response formats, request parameters, response parameters, and more. This helps them make better use of apis and improve development efficiency. Second, API mind maps can be used as a communication tool between teams. By sharing a mind map, team members can more quickly understand each other's ideas and work together to solve problems. In addition, mind maps make it easy to record and review updates and changes to the API. As the API is updated and iterated, the mind map can be updated at any time, making it easy for developers to quickly stay up to date. All in all, the benefits of API mind mapping are increased development efficiency, improved team communication, and easy documentation and review. This is a mind map for ZongmuAIP.java. The map contains three main branches: initialize(), initializeSDK(), surfaceCreated(). The map provides a detailed description of the last two branches in hierarchical expansion. Suitable for those who are interested in API and taste.
Edited at 2023-08-09 01:28:39- Recommended to you
- Outline
BYD AVM SDK
avm3d_chnview_gui.cpp
init()
avm3d_topview_gui.cpp
init()
avm3d_root_gui.cpp
init()
avm3d_sideview.cpp
init()
avm3d_chnview.cpp
init()
avm3d_topview.cpp
init()
avm3d_car_shadow.cpp
init()
avm3d_car.cpp
init()
avm3d_animation.cpp
init()
zros_ui_app.cpp
class zros_ui_app { public: zros_ui_app(zros_ui_inst* inst); virtual ~zros_ui_app(); zm_viewport* get_app_viewport() { return m_viewport_app; } zm_viewport* get_gui_viewport() { return m_viewport_gui; } virtual bool init(bool visible = false); virtual void deinit() {} virtual bool inst_init(); virtual void inst_deinit(); virtual bool is_visible(); virtual void set_visible(bool visible); virtual void inst_pre_render(unsigned long long time_us) {} virtual void inst_post_render() {} virtual void event_handler(int id, int app_id, int event, unsigned long data, unsigned int attributes); protected: bool m_inited; zros_ui_inst* m_inst = nullptr; zm_viewport* m_viewport_app = nullptr; zm_viewport* m_viewport_gui = nullptr; };
inst_pre_render()
set_visible()
void zros_ui_app::set_visible(bool visible) { if (m_inited) { m_viewport_app->set_visible(visible); } else { m_inst->AddTask(std::bind(&zros_ui_app::init, this, visible)); } }
m_inst->AddTask(std::bind(&zros_ui_app::init, this, visible));
init()
bool zros_ui_app::init(bool visible) { m_viewport_gui->set_render_order(VIEWPORT_RENDER_ORDER_LAST); m_viewport_app->set_visible(visible); return true; }
inst_init()
bool zros_ui_app::inst_init() { m_viewport_app = zm_viewport_create(m_inst, m_inst->get_root_viewport()); if (!m_viewport_app) { ZERROR << "zm_viewport_create m_viewport_app failed" << std::endl; goto _error_handler; } m_viewport_gui = zm_viewport_create(m_inst, m_viewport_app); if (!m_viewport_gui) { ZERROR << "zm_viewport_create m_viewport_gui failed" << std::endl; goto _error_handler; } return true; _error_handler: inst_deinit(); return false; }
zm_3d_inst.cpp
class ZM_3D_INSTANCE { public: ZM_3D_INSTANCE(); virtual ~ZM_3D_INSTANCE(); int init(); void deinit(); virtual int inst_init() { return true; }; virtual void inst_deinit() { return; }; virtual bool inst_pre_render(unsigned long long) { return true; }; virtual void inst_post_render() { return; }; virtual void inst_event_handler(int id, int app_id, int event, unsigned long data, unsigned int attributes); void send_event(int id, int app_id, int event, unsigned long data, unsigned int attributes = 0); void set_capturing_gesture(int capturing) { m_capturing_gesture = capturing; } int is_capturing_gesture() { return m_capturing_gesture; } void set_render_enable(int enable); int get_render_enable() { return m_render_enable.load(); }; void lock(); void unlock(); int trylock(); void render_thread(); int is_ready_show(); void render(); ZM_3D_VIDEO *get_video() { return m_video; }; zm_color_balance *get_color_balance() { return m_color_balance; }; zm_3d_node_mgr *get_node_mgr() { return m_node_mgr; } unsigned get_time(); void update_time(); float get_screen_aspect() { return m_screen_aspect; }; void set_screen_aspect(float aspect) { m_screen_aspect = aspect; }; void on_screen_changed() { ZDEBUG("%s %d\n", __func__, __LINE__); m_root_viewport->set_viewport(NULL); }; const ZM_RECT_SIZE &get_fb_size(); zm_viewport *get_root_viewport() { return m_root_viewport; }; void set_3d_context(ZM_3D_CONTEXT *ctx) { if (ctx) ctx->SetInst(this); m_zm_ctx = ctx; }; ZM_3D_CONTEXT *get_3d_context() { return m_zm_ctx; }; unsigned get_flags(); void set_flags(unsigned flags); int is_in_render_thrd(); int m_view_obj_nr[ZM_VIEW_OBJ_MAX_NR]; struct ZM_3D_RENDER_OBJ_INFO m_render_objs[ZM_RENDER_OBJ_MAX_NR]; unsigned get_platform_flags() { return m_platform_flags; }; void set_platform_flags(unsigned flags) { m_platform_flags = flags; }; void set_visible(int visible); int alloc_obj_id() { return m_curr_obj_id++; }; std::recursive_mutex m_lock; std::unordered_map<std::string, void *> m_tex_path_map; std::list<zm_texture *> m_textures; int get_status() { return m_status.load(); }; const char *get_language() { return m_language.c_str(); }; void reload_textures(); void deinit_textures(); void set_language(const std::string &new_langurage); void set_input_event(PZM_INPUT_EVENT input_event); bool should_show_cursor() { return show_cursor; }; void set_show_cursor(bool show) { show_cursor = show; }; void get_screen_render_size(PZM_FRECT_SIZE size); int get_rotation_angle() { return m_rotation_angle; } void capture_snapshot(const std::string & capture_path); public: float m_screen_aspect; ZM_3D_VIDEO *m_video; zm_color_balance *m_color_balance; zm_3d_node_mgr *m_node_mgr; zm_viewport *m_root_viewport; private: int _context_init(); void _context_deinit(); void _do_snapshot(); void _check_input_trigger_snapshot(const ZM_INPUT_EVENT &input); ZM_3D_CONTEXT *m_zm_ctx; unsigned m_contex_attribute; int m_capturing_gesture; char *m_render_thrd_stack; std::thread m_render_thread; std::atomic<bool> m_thrd_exit = {false}; std::atomic<bool> m_thrd_running = {false}; std::atomic<bool> m_thrd_paused = {true}; zros::core::Event m_render_event; zros::core::Event m_render_running_event; std::atomic<bool> m_render_enable = {false}; std::atomic<bool> m_ready_show = {false}; unsigned m_time; unsigned m_flags; unsigned m_platform_flags; int m_curr_obj_id; std::atomic<int> m_status = {ZM_3D_STATUS_INIT}; std::string m_language; int m_rotation_angle; ZM_RECT_SIZE m_screen_size; ZM_3D_RECT m_render_range; bool show_cursor = false; std::string m_capture_path; bool m_capture_status = false; bool m_render_stopped; };
init()
int ZM_3D_INSTANCE::init() { ZINFO("ZM_3D_INSTANCE::init\n"); update_time(); ZASSERT(m_zm_ctx); m_contex_attribute = m_zm_ctx->GetAttribute(); unsigned start_tick = zm_get_tick_count(); unsigned new_tick = zm_get_tick_count(); m_thrd_exit.store(false); m_color_balance = zm_color_balance_factory(this); m_node_mgr = zm_3d_node_mgr_create(); if (m_contex_attribute & CONTEXT_ATTR_NEED_RENDER_THREAD) { m_thrd_running.store(false); m_render_thread = std::thread([this]() { this->render_thread(); }); //todo brice.liu if (!m_thrd_running.load()){ zerror("Wait m_thrd_running"); m_render_running_event.Wait(); zerror("Waited m_thrd_running"); } } else _context_init(); m_status.store(ZM_3D_STATUS_RUN); zerror("BOOT_TIME_MARK ZM_3D_INSTANCE::init cost %d ms\n", zm_get_tick_count() - start_tick); return true; }
m_render_thread = std::thread([this]() { this->render_thread(); });
render_thread()
render()
void ZM_3D_INSTANCE::render() { unsigned long long tm_; ZASSERT(is_in_render_thrd()); if (m_video) m_video->set_run(true); if (!(m_contex_attribute & CONTEXT_ATTR_INST_DONOT_HANDLE_VIDEO)) { #ifndef PLATFORM_ARCH_ANDROID_AARCH64 if (m_video) { tm_ = m_video->get_frame(); // ZERROR("m_video->get_frame %lld\n", tm_); // m_color_balance->update(); } #endif } #ifdef PLATFORM_ARCH_ANDROID_AARCH64 static int balance_count = 0; if (++balance_count >= 3) { balance_count = 0; m_color_balance->update_use_manual_ROI(SDKEngineInst()->GetColorBalanceROI()); } #endif if (inst_pre_render(tm_)) { #ifndef PLATFORM_ARCH_ANDROID_AARCH64 m_zm_ctx->PreRender(); #endif update_time(); lock(); m_root_viewport->render(); unlock(); inst_post_render(); m_zm_ctx->PostRender(); } if (!(m_contex_attribute & CONTEXT_ATTR_INST_DONOT_HANDLE_VIDEO)) { #ifndef PLATFORM_ARCH_ANDROID_AARCH64 if (m_video) m_video->put_frame(); #endif } if (!(m_contex_attribute & CONTEXT_ATTR_NEED_RENDER_THREAD)) { m_ready_show.store(true); static unsigned fps = 0; static unsigned tick = 0; fps++; if (zm_get_tick_count() - tick >= 8000) { tick = zm_get_tick_count(); ZINFO << zm_proc_info()->real_name << " fps " << fps / 8 << std::endl; fps = 0; } } }
inst_pre_render()
m_root_viewport->render()
inst_post_render()
set_render_enable()
avm3d_app.cpp
class avm3d_app : public zros_ui_app { public: avm3d_app(zros_ui_inst* inst); ~avm3d_app(); bool init(bool visible) override; void deinit() override; bool inst_init() override; void inst_deinit() override; void inst_pre_render(unsigned long long time_us) override; avm3d_animation* get_animation() { return m_animation; } avm3d_car* get_car() { return m_car; } avm3d_car_shadow* get_car_shadow() { return m_car_shadow; } avm3d_trajectory* get_trajectory() { return m_trajectory; } avm3d_trajectory_2d* get_trajectory_2d() { return m_trajectory_2d; } avm3d_obstacle* get_obstacle() { return m_obstacle; } avm3d_obstacle_2d* get_obstacle_2d() { return m_obstacle_2d; } avm3d_topview* get_topview() { return m_topview; } avm3d_chnview* get_chnview() { return m_chnview; } avm3d_sideview* get_sideview() { return m_sideview; } void set_layout(int layout, int no_trans); void apply_demo_data(); void apply_all_settings(); void play_animation(int loop, int layout, int no_trans); void stop_animation(); void on_animation_finish(); static void animation_finish_handler(unsigned long context, int data); void set_chnview_type(int type); void set_car_wheel_angle(float angle); void set_car_door_status(CAR_DOORS_STATUS& door_status); void set_car_shadow_type(int type); void set_car_visible(int visible); void update_car_color(); void set_trajectory_wheel_angle(float angle); void set_trajectory_visible(int traj_id, int visible); void set_2d_trajectory_visible(int traj_id, int visible); void create_obstacle_2d_obj(); void create_trajectory_obj(); void create_trajectory_2d_obj(); void set_obstacle_visible(int visible); void set_2d_obstacle_visible(int visible); void set_radar_data(const USS_PDC_DATA& radar_data); void set_2d_radar_data(const USS_PDC_DATA& radar_data); void set_view(int view); void start_calibration(); void apply_on_the_fly(); void save_shadow(); void reset_shadow(); void set_time_mark_visible(bool visible); void set_time_mark_font_size(int fontSize); void set_time_mark_position(int x, int y); void root_gui_gesture_double_click_handler(int x, int y); void chnview_gui_gesture_moving_handler(int x, int y, int no_trans); void action_root_close_handler(); void action_root_reload_handler(); void action_root_reset_to_factory_handler(); void action_root_snapshot_handler(); void update_fps_mark(float fps); bool m_trajectory_2d_need_create = false; bool m_trajectory_need_create = false; private: bool is_landscape_3d_view(int view); bool is_portrait_3d_view(int view); bool using_wide_raw_view(); int m_view; int m_layout; int m_animation_restore_layout; dr_mgr m_dr_mgr; avm3d_animation* m_animation; avm3d_car* m_car; avm3d_car_shadow* m_car_shadow; avm3d_car_shadow* m_car_shadow_aroundview; avm3d_trajectory* m_trajectory; avm3d_trajectory_2d* m_trajectory_2d; avm3d_obstacle* m_obstacle; avm3d_obstacle_2d* m_obstacle_2d; avm3d_topview* m_topview; avm3d_chnview* m_chnview; avm3d_sideview* m_sideview; avm3d_root_gui* m_root_gui; avm3d_topview_gui* m_topview_gui; avm3d_chnview_gui* m_chnview_gui; bool m_first_render; };
avm3d_app()
avm3d_app::avm3d_app(zros_ui_inst* inst) : zros_ui_app(inst) , m_view(-1) , m_layout(-1) , m_animation_restore_layout(0) , m_animation(NULL) , m_car(NULL) , m_car_shadow(NULL) , m_car_shadow_aroundview(NULL) , m_trajectory(NULL) , m_trajectory_2d(NULL) , m_obstacle(NULL) , m_obstacle_2d(NULL) , m_topview(NULL) , m_chnview(NULL) , m_sideview(NULL) , m_root_gui(NULL) , m_topview_gui(NULL) , m_chnview_gui(NULL) , m_first_render(true) { }
inst_pre_render()
void avm3d_app::inst_pre_render(unsigned long long time_us) { DR_INSTANCE dr; m_dr_mgr.update(time_us, m_first_render, dr); if (m_first_render || (dr.offset.x != 0 || dr.offset.y != 0 || dr.angle < -0.00001 || dr.angle > 0.00001)) { get_car_shadow()->update_dr(dr); } m_root_gui->update_time_mark(); //obj需要在render线程创建 if(avm3d_cfg_get()->obstacle.visible) { if (!m_obstacle_2d) { create_obstacle_2d_obj(); } if (avm3d_cfg_get()->obstacle.uss_data_changed) { if (m_obstacle_2d) { m_obstacle_2d->set_radar_data(avm3d_cfg_get()->obstacle.demo_data); } } } if (m_obstacle_2d) { m_obstacle_2d->set_visible(avm3d_cfg_get()->obstacle.visible); } if(!m_trajectory_2d && m_trajectory_2d_need_create) { create_trajectory_2d_obj(); m_trajectory_2d->set_wheel_angle(avm3d_cfg_get()->trajectory.demo_data.wheel_angle); } if(!m_trajectory && m_trajectory_need_create) { create_trajectory_obj(); m_trajectory->set_wheel_angle(avm3d_cfg_get()->trajectory.demo_data.wheel_angle); } if (m_first_render) { // m_car_shadow_aroundview->update_dr(dr); m_first_render = false; PAVM3D_ANIMATION_CFG cfg_animation = &avm3d_cfg_get()->animation; if (cfg_animation->startup_animation) { play_animation(false, AVM3D_LAYOUT_CHNVIEW_FULL_SCREEN, true); } } }
init()
bool avm3d_app::init(bool visible) { if (m_inited) { return true; } if (!avm3d_cfg_init()) { ZERROR << "avm3d_cfg_init failed" << std::endl; return false; } if (!inst_init()) { ZERROR << "inst_init failed" << std::endl; return false; } if (!avm3d_msg_init(this)) { ZERROR << "avm3d_msg_init failed" << std::endl; return false; } if (!avm3d_setting_init(this)) { ZERROR << "avm3d_setting_init failed" << std::endl; return false; } zros_ui_app::init(visible); m_inited = true; m_first_render = true; return true; }
inst_init()
zros_ui_app::init(visible);
inst_init()
bool avm3d_app::inst_init() { PAVM3D_CFG cfg = avm3d_cfg_get(); PAVM3D_CMN_CFG cfg_cmn = &cfg->cmn; if (!zros_ui_app::inst_init()) { ZERROR << "zros_ui_app::inst_init failed" << std::endl; goto _error_handler; } m_animation = new avm3d_animation(); if (!m_animation->init()) { ZERROR << "m_animation init failed" << std::endl; goto _error_handler; } m_car = new avm3d_car(m_inst); if (!m_car->init()) { ZERROR << "m_car init failed" << std::endl; goto _error_handler; } m_car_shadow = new avm3d_car_shadow(m_inst); if (!m_car_shadow->init()) { ZERROR << "m_car_shadow init failed" << std::endl; goto _error_handler; } m_car_shadow_aroundview = new avm3d_car_shadow(m_inst); if (!m_car_shadow_aroundview->init()) { ZERROR << "m_car_shadow_aroundview init failed" << std::endl; goto _error_handler; } // m_obstacle = new avm3d_obstacle(m_inst); // if (!m_obstacle->init()) // { // ZERROR << "m_obstacle init failed" << std::endl; // goto _error_handler; // } m_topview = new avm3d_topview(this, m_viewport_app); if (!m_topview->init(cfg->topview)) { ZERROR << "m_topview init failed" << std::endl; goto _error_handler; } m_chnview = new avm3d_chnview(this, m_viewport_app); if (!m_chnview->init(cfg->chnview)) { ZERROR << "m_chnview init failed" << std::endl; goto _error_handler; } m_sideview = new avm3d_sideview(this, m_viewport_app); if (!m_sideview->init(cfg->sideview)) { ZERROR << "m_sideview init failed" << std::endl; goto _error_handler; } m_root_gui = new avm3d_root_gui(this, m_viewport_gui, cfg_cmn->gui_cmn.cursor_pic); if (!m_root_gui->init(cfg->gui)) { ZERROR << "m_root_gui init failed" << std::endl; goto _error_handler; } m_topview_gui = new avm3d_topview_gui(this, m_topview->get_gui_viewport()); if (!m_topview_gui->init(cfg->topview)) { ZERROR << "m_topview_gui init failed" << std::endl; goto _error_handler; } m_chnview_gui = new avm3d_chnview_gui(this, m_chnview->get_gui_viewport()); if (!m_chnview_gui->init(cfg->chnview)) { ZERROR << "m_chnview_gui init failed" << std::endl; goto _error_handler; } m_topview->set_view_obj(AVM3D_RENDER_ORDER_CAR_SHADOW, get_car_shadow()->get_view_obj()); m_chnview->get_aroundview()->set_view_obj(AVM3D_RENDER_ORDER_CAR, m_car->get_view_obj()); apply_all_settings(); return true; _error_handler: inst_deinit(); return false; }
zros_ui_app::inst_init()
set_view()
void avm3d_app::set_view(int view) { PAVM3D_CFG cfg = avm3d_cfg_get(); PAVM3D_CHNVIEW_CFG cfg_chnview = &cfg->chnview; switch (view) { case AVM3D_VIEW_ID_2D_LANDSCAPE_FRONT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_FRONT); break; case AVM3D_VIEW_ID_2D_LANDSCAPE_LEFT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_LANDSCAPE_REAR: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_REAR); break; case AVM3D_VIEW_ID_2D_LANDSCAPE_RIGHT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_2D_LANDSCAPE_FRONT_WIDE: set_layout(AVM3D_LAYOUT_CHNVIEW_FULL_SCREEN, true); if (using_wide_raw_view()) { set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_FRONT); } else { set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_FRONT); } break; case AVM3D_VIEW_ID_2D_LANDSCAPE_REAR_WIDE: set_layout(AVM3D_LAYOUT_CHNVIEW_FULL_SCREEN, true); if (using_wide_raw_view()) { set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_REAR); } else { set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_REAR); } break; case AVM3D_VIEW_ID_2D_LANDSCAPE_RIM: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RIMVIEW); m_chnview->get_rimview()->set_view_id(cfg_chnview->rimview, AVM3D_RIMVIEW_VIEW_ID_FRONT); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_FRONT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_LEFT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_LEFT, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_REAR: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_REAR, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_RIGHT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_RIGHT, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_FRONT_LEFT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_LEFT, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_3D_LANDSCAPE_FRONT_RIGHT: set_layout(AVM3D_LAYOUT_DEFAULT, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_RIGHT, !is_landscape_3d_view(m_view)); break; case AVM3D_VIEW_ID_2D_PORTRAIT_FRONT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_FRONT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_REAR_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_REAR); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_REAR_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RAW); m_chnview->get_chn_raw()->set_active_channel(CHANNEL_REAR); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_FRONT_WIDE_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_FRONT_WIDE_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_REAR_WIDE_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_REAR); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_REAR_WIDE_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_SIDE); m_chnview->get_chn_side()->set_active_channel(CHANNEL_REAR); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_RIM_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RIMVIEW); m_chnview->get_rimview()->set_view_id(cfg_chnview->rimview, AVM3D_RIMVIEW_VIEW_ID_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_2D_PORTRAIT_RIM_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_RIMVIEW); m_chnview->get_rimview()->set_view_id(cfg_chnview->rimview, AVM3D_RIMVIEW_VIEW_ID_FRONT); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_LEFT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_LEFT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_LEFT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_LEFT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_REAR_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_REAR, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_REAR_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_REAR, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_RIGHT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_RIGHT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_RIGHT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_RIGHT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONTLEFT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_LEFT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONTLEFT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_LEFT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONTRIGHT_LEFT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_RIGHT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_LEFT); break; case AVM3D_VIEW_ID_3D_PORTRAIT_FRONTRIGHT_RIGHT: set_layout(AVM3D_LAYOUT_VERTICAL, true); set_chnview_type(ZROS_UI_SETTING_VIEW_TYPE_AROUNDVIEW); m_chnview->get_aroundview()->set_view_id(cfg_chnview->aroundview, AVM3D_AROUNDVIEW_VIEW_ID_OUTER_FRONT_RIGHT, !is_portrait_3d_view(m_view)); m_sideview->set_active_channel(cfg->sideview, CHANNEL_RIGHT); break; default: ZERROR << "unknown view id: " << view << std::endl; break; } m_view = view; }
zros_ui_app_mgr.cpp
class zros_ui_app_mgr { public: zros_ui_app_mgr(); ~zros_ui_app_mgr(); bool init(zros_ui_inst* inst); void deinit(); bool init_apps(); void deinit_apps(); void show_app(int app_id); zros_ui_app* get_app(int app_id); void inst_pre_render(unsigned long long time_us); void inst_post_render(); void event_handler(int id, int app_id, int event, unsigned long data, unsigned int attributes); private: std::recursive_mutex m_mutex; zros_ui_inst* m_inst; int m_cur_app_id; int m_next_app_id; zros_ui_app* m_apps[ZROS_UI_APP_MAX]; };
init()
bool zros_ui_app_mgr::init(zros_ui_inst* inst) { m_inst = inst; m_cur_app_id = ZROS_UI_APP_NONE; m_next_app_id = ZROS_UI_APP_NONE; for (int app_id = 0; app_id < ZROS_UI_APP_MAX; ++app_id) { m_apps[app_id] = create_zros_ui_app(inst, app_id); if (!m_apps[app_id]) { ZERROR << "create_zros_ui_app(" << app_id << ") failed"; return false; } } return true; }
m_apps[app_id] = create_zros_ui_app(inst, app_id);
create_zros_ui_app()
static zros_ui_app* create_zros_ui_app(zros_ui_inst* inst, int app_id) { switch (app_id) { case ZROS_UI_APP_FIO3D: return new fio3d_app(inst); break; case ZROS_UI_APP_AVM3D: return new avm3d_app(inst); break; default: ZERROR << "unknown app id: " << app_id << std::endl; break; } return NULL; }
avm3d_app(inst);
fio3d_app(inst);
inst_pre_render()
void zros_ui_app_mgr::inst_pre_render(unsigned long long time_us) { if (m_cur_app_id != ZROS_UI_APP_NONE) { m_apps[m_cur_app_id]->inst_pre_render(time_us); } }
m_apps[m_cur_app_id]->inst_pre_render();
inst_post_render()
void zros_ui_app_mgr::inst_post_render() { if (m_cur_app_id != ZROS_UI_APP_NONE) { m_apps[m_cur_app_id]->inst_post_render(); } m_mutex.lock(); if (m_next_app_id != ZROS_UI_APP_NONE) { if (m_cur_app_id != ZROS_UI_APP_NONE) { m_apps[m_cur_app_id]->set_visible(false); } m_cur_app_id = m_next_app_id; m_apps[m_cur_app_id]->set_visible(true); m_next_app_id = ZROS_UI_APP_NONE; } m_mutex.unlock(); }
m_apps[m_cur_app_id]->set_visible()
zros_ui_inst.cpp
class zros_ui_inst : public ZM_3D_INSTANCE { public: zros_ui_inst(); ~zros_ui_inst(); static zros_ui_inst* Instance(void); bool Init(DisplayConfig config); void Deinit(); void Run(); void AddTask(TASK task); void ShowApp(int app_id); zros_ui_app* GetApp(int app_id) { return m_app_mgr.get_app(app_id); } bool IsExit() { return m_exit; } void SetExit(bool exit) { m_exit = exit; } void *GetAvmFbHandle(); void PutAvmFbHandle(void * handle); void OnScreenChanged(void * config); void OnWindowChanged(void * config); PZM_RAW_IMG GetSplitCameraImage(); private: int inst_init() override; void inst_deinit() override; bool inst_pre_render(unsigned long long time_us) override; void inst_post_render() override; void inst_event_handler(int id, int app_id, int event, unsigned long data, unsigned int attributes) override; private: bool m_exit; zros_ui_app_mgr m_app_mgr; zros_ui_task_queue m_task_queue; ZM_3D_CONTEXT* m_3d_context = nullptr; PZM_RAW_IMG m_split_frame; };
Instance()
zros_ui_inst* zros_ui_inst::Instance(void) { static zros_ui_inst instance; return &instance; }
Init()
bool zros_ui_inst::Init(DisplayConfig config) { m_exit = false; if (!m_app_mgr.init(this)) { ZERROR << "m_app_mgr init failed" << std::endl; return false; } #ifdef PLATFORM_ARCH_ANDROID_AARCH64 m_3d_context = Create3DContextNative(config); #else m_3d_context = Create3DContextOffScreen(config); #endif assert(m_3d_context); set_3d_context(m_3d_context); set_flags(ZM_3D_INST_FLAG_NEED_AA); return ZM_3D_INSTANCE::init(); }
m_app_mgr.init()
ZM_3D_INSTANCE::init();
inst_pre_render()
bool zros_ui_inst::inst_pre_render(unsigned long long time_us) { static uint32_t first = 0; static unsigned long long ts_us = 0; TASK task; #ifdef PLATFORM_ARCH_ANDROID_AARCH64 if (!SDKEngineInst()->FilterProcess(ts_us)) // todo: if render too early return false; #else ts_us = time_us; #endif while (m_task_queue.get_task(task)) { task(); } m_app_mgr.inst_pre_render(ts_us); return true; }
m_app_mgr.inst_pre_render()
inst_post_render()
void zros_ui_inst::inst_post_render() { m_app_mgr.inst_post_render(); }
m_app_mgr.inst_post_render();
zros_ui_main.cpp
Avm3DInstance()
SurroundViewUI* Avm3DInstance() { static SurroundViewUI avm3dUI; return &avm3dUI; }
Init()
bool SurroundViewUI::Init(DisplayConfig config) { _first_resume_finished = false; PZROS_UI_CFG cfg; //ZADAS_INIT::instance(); ZINFO("SurroundViewUI::Init DisplayConfig(%dx%d)", config.width, config.height); ZDEBUG << zm_proc_info()->real_name << " started" << std::endl; if (!zros_ui_cfg_init()) { ZERROR << "zros_ui_cfg_init failed" << std::endl; goto _exit; } if (!zros_ui_inst::Instance()->Init(config)) { ZERROR << "s_inst init failed" << std::endl; goto _exit; } if (!zros_ui_msg_init(zros_ui_inst::Instance())) { ZERROR << "zros_ui_cfg_init failed" << std::endl; goto _exit; } //cfg = zros_ui_cfg_get(); // zros_ui_inst::Instance()->ShowApp(cfg->startup_app_id); // zros_ui_inst::Instance()->set_render_enable(true); ZINFO("SurroundViewUI::Init DisplayConfig --"); return true; _exit: Deinit(); ZERROR("SurroundViewUI::Init DisplayConfig error--"); return false; }
zros_ui_inst::Instance()->Init(config)
Resume()
void SurroundViewUI::Resume() { ZINFO("SurroundViewUI::Resume %s +", zadas_version_string()); // ZDEBUG("%s +", __FUNCTION__); PZROS_UI_CFG cfg; cfg = zros_ui_cfg_get(); zros_ui_inst::Instance()->ShowApp(cfg->startup_app_id); zros_ui_inst::Instance()->set_render_enable(true); if (!_first_resume_finished) { //进程启动后第一次环视在此处调用set_view和UpdateTrajVisible avm3d_app *p_avm3d_app = dynamic_cast<avm3d_app *>(zros_ui_inst::Instance()->GetApp(ZROS_UI_APP_AVM3D)); if (nullptr == p_avm3d_app) { ZINFO("SurroundViewUI::Resume nullptr == p_avm3d_app"); _first_resume_finished = true; return; } ZINFO("SurroundViewUI::Resume p_avm3d_app vaild"); update_car_color(car_body_color_); p_avm3d_app->set_view(_zm_view_id); UpdateTrajVisible(); float wheelAngle = get_wheel_angle(_raw_steer_angle); p_avm3d_app->set_trajectory_wheel_angle(wheelAngle); p_avm3d_app->set_car_wheel_angle(wheelAngle); _first_resume_finished = true; } ZINFO("SurroundViewUI::Resume -"); }
zros_ui_inst::Instance()->set_render_enable(true);
avm3d_app *p_avm3d_app = dynamic_cast<avm3d_app *>(zros_ui_inst::Instance()->GetApp(ZROS_UI_APP_AVM3D))
p_avm3d_app->set_view()
Suspend
void SurroundViewUI::Suspend() { ZINFO("SurroundViewUI::Suspend +"); // ZDEBUG("%s +", __FUNCTION__); // zros_ui_inst::Instance()->set_render_enable(false); avm3d_app *p_avm3d_app = dynamic_cast<avm3d_app *>(zros_ui_inst::Instance()->GetApp(ZROS_UI_APP_AVM3D)); if (nullptr == p_avm3d_app) { return; } p_avm3d_app->save_shadow(); zros_ui_inst::Instance()->set_render_enable(false); ZINFO("SurroundViewUI::Suspend -"); }
zros_ui_inst::Instance()->set_render_enable(false);
sdk_engine_android_x86_64.cpp
SDKEngineInst()
SDKEngine engineInst; SDKEngine* SDKEngineInst() { return &engineInst; }
Start()
mMainThread = std::thread(&SDKEngine::mainLoop, this);
mainLoop()
void SDKEngine::mainLoop() { ZDEBUG("SDKEngine mainLoop"); mCameraClient = nullptr; ZADAS_INIT& zadas_init_instance = ZADAS_INIT::instance(); ZDEBUG("SDKEngine::InitCameraServer start"); zros::camera::InitCameraServer(); InitCamera(SDKContext()->camera); ZDEBUG("zongmu_sdk_surface SDKEngine::SDKEngine Avm3DInstance()->Init"); DisplayConfig disp; disp.width = ANDROID_SURFACE_WIDTH_DEFAULT; disp.height = ANDROID_SURFACE_HEIGHT_DEFAULT; InitVechicleConfig(ANDROID_ZROS_CAR_TYPE, ANDROID_ZROS_SUB_CAR_TYPE, ANDROID_ZROS_CAR_COLOR, ANDROID_ZROS_RES_CAR_PANO_DIR); ApplyVechicleConfig(); Avm3DInstance()->Init(disp); Avm3DInstance()->SetCarResources(SDKContext()->vehicle.car_type, SDKContext()->vehicle.sub_car_type, SDKContext()->vehicle.car_body_color, SDKContext()->vehicle.car_resource_path); zros::core::SetSelfThreadPriority(zros::core::ThreadPriority::NORMAL); zros::core::SetSelfThreadName("SdkMainLoop"); while (IsRunning()) { //zros::core::Sleep(500); stop_event_.Wait(); ZDEBUG("##################SDKEngine mainLoop: exit ##################"); } ZDEBUG("zongmu_sdk_surface SDKEngine mainLoop Avm3DInstance()->Deinit + "); Avm3DInstance()->Deinit(); ZDEBUG("zongmu_sdk_surface SDKEngine mainLoop DeinitCameraServer + "); zros::camera::DeinitCameraServer(); ZDEBUG("zongmu_sdk_surface SDKEngine mainLoop -"); }
Avm3DInstance()->Init(disp);
Avm3DInstance()->SetCarResources()
Avm3DInstance()->Deinit();
Resume()
void SDKEngine::Resume() { ZDEBUG("SDKEngine::Resume"); if (!mResuming.exchange(true)) { ZDEBUG("SDKEngine %p (%dx%d) , SDKContext()->disp.window, SDKContext()->disp.width, SDKContext()->disp.height); SDKContext()->status.store(APP_STATUS_SURFACE_RESUMING); ZDEBUG("SDKEngine APP_STATUS_SURFACE_RESUMING"); mWindow = SDKContext()->disp.window; mRenderThread = std::thread(&SDKEngine::Render, this); }else{ ZERROR("SDKEngine::Resume already running?"); } ZDEBUG("SDKEngine::Resume -"); }
mRenderThread = std::thread(&SDKEngine::Render, this);
Render()
void SDKEngine::Render() { ZDEBUG("SDKEngine Render start"); Avm3DInstance()->Resume(); mResuming = true; ZDEBUG("SDKEngine Render "); if(!Initialise()){ ZERROR("SDKEngine Render Initialise failed"); ZASSERT(0); } setupGraphics(); mWindowInited = true; zros::core::SetSelfThreadPriority(zros::core::ThreadPriority::TIME_CRITICAL); zros::core::SetSelfThreadName("Render"); while (IsResuming()) { DrawFrame(); } ZDEBUG("zongmu_sdk_surface SDKEngine::SDKEngine Destroy ++"); Avm3DInstance()->Suspend(); Destroy(); ZDEBUG("SDKEngine Render exit"); }
Avm3DInstance()->Resume();
Avm3DInstance()->Suspend();
ZongmuSurfaceAPI.cpp
nativeInitializeSDK()
JNIEXPORT void JNICALL ZONGMU_API(nativeInitializeSDK)(JNIEnv *env, jclass clazz, jstring res_path, jint width, jint height, jstring param_path, jstring common_res_path) { const char *p_res_path = env->GetStringUTFChars(res_path, JNI_FALSE); const char *p_param_path = env->GetStringUTFChars(param_path, JNI_FALSE); const char *p_common_res_path = env->GetStringUTFChars(common_res_path, JNI_FALSE); LOGI("ZongmuJNI initializeSDK() camera resolution(%dx%d) res_path(%s) param_path(%s) common_res_path(%s)\n", width, height, p_res_path, p_param_path, p_common_res_path); SDKContext()->camera.width = width; // what is SDKContext()? SDKContext()->camera.height = height; LOGI("ZongmuJNI initializeSDK() SDKContext()->camera.height was temporarily fixed to %d.",SDKContext()->camera.height); SDKEngineInst()->InitRuntimeConfig(p_res_path, p_param_path, p_common_res_path); // What is SDKEngineInst()? SDKEngineInst()->Start(); env->ReleaseStringUTFChars(res_path, p_res_path); env->ReleaseStringUTFChars(param_path, p_param_path); env->ReleaseStringUTFChars(common_res_path, p_common_res_path); }
SDKEngineInst()->Start();
nativeOnSurfaceCreated()
JNIEXPORT void JNICALL ZONGMU_API(nativeOnSurfaceCreated)(JNIEnv *env, jobject instance, jobject surface) { LOGI("ZongmuJNI nativeOnSurfaceCreated\n"); if (!SDKContext()->disp.window) { SDKContext()->disp.window = ANativeWindow_fromSurface(env, surface); LOGI("ZongmuJNI nativeOnSurfaceCreated SDKContext()->disp.window-%p from surface-%p\n", SDKContext()->disp.window, surface); }else{ LOGE("ZongmuJNI nativeOnSurfaceCreated window-%p already exist!!! new surface-%p\n", SDKContext()->disp.window, surface); SDKEngineInst()->checkSuspendFinish(); SDKContext()->disp.window = ANativeWindow_fromSurface(env, surface); } SDKContext()->disp.width = ANativeWindow_getWidth(SDKContext()->disp.window); SDKContext()->disp.height = ANativeWindow_getHeight(SDKContext()->disp.window); Avm3DInstance()->SetScreenSize(SDKContext()->disp.width, SDKContext()->disp.height); SDKContext()->status = APP_STATUS_SURFACE_RESUMING; SDKEngineInst()->Resume(); SDKEngineInst()->waitInitFinish(); LOGI("ZongmuJNI MsgSurfaceViewCreated surface size (%dx%d)\n", SDKContext()->disp.width, SDKContext()->disp.height); }
SDKEngineInst()->Resume();
ZongmuAPI.java
initialize()
initializeSDK()
public void initializeSDK(String resPath, int width, int height, String paramPath, Context context, String commonResPath){ Log.e(TAG, "ZongmuAPI initializeSDK" ); nativeInitializeSDK(resPath, width, height, paramPath, commonResPath); }
nativeInitializeSDK();
private native void nativeInitializeSDK(String resPath, int width, int height, String paramPath, String commonResPath);
surfaceCreated()
nativeOnSurfaceCreated()