Enterprise WeChat iOS Architecture Transformation: Componentization and Plugin Integration Practices

As a large-scale iOS project with over 8 million lines of code, Enterprise WeChat (Wecom) integrates features like Tencent Meeting, Tencent Docs, and Enterprise Email. The rapidly expanding code base and functional modules brought significant challenges: compilation time increased to approximately 80 minutes for full builds and over 20 minutes for incremental builds, Xcode project files became bloated causing slow loading and lag, and severe module coupling made maintenance and testing increasingly difficult.

To address these challenges, the Wecom team undertook a comprehensive architecture transformation focusing on componentization and plugin integration capabilities.

Architecture Overview

The new architecture consists of four layers: Common Layer, Common Base Layer, UI Framework Layer, and Feature Modules . The common and base layers are written in C++ for cross-platform code reuse across iOS, Android, Mac, Windows, and Linux. The iOS UI layer uses Objective-C to implement business components, with a Component Management Center providing lifecycle management, inter-component communication, and notification management capabilities.

Componentization Work Breakdown

The team identified over 70 components containing approximately 17,000 source files and 8 million lines of code. The componentization work was divided into four phases:

Infrastructure Building : Implementing the component management container for lifecycle management, inter-component communication, and notification listening.

Physical Directory Splitting : Creating independent folders for each component to achieve physical isolation.

Dependency Analysis : Analyzing external dependencies and exposed interfaces using AST parsing with Clang LibTooling.

Component Splitting : Encapsulating exposed interfaces and converting direct references to interface-based calls.

Component Management Center (ModuleManager)

The ModuleManager provides: component lifecycle management, inter-component communication via protocol-based service registration, system/application event notifications, privacy permission management, and multi-account data isolation.

Dependency Analysis Approach

The team evaluated three approaches for dependency analysis:

Header File Analysis : Simple but coarse-grained, only accurate to file level.

Linker Log Analysis : Precise to symbol level but requires constructing many sub-projects.

AST Parsing (Final Choice) : Using Clang LibTooling's ASTMatcher to extract function definitions, calls, variable definitions, and class references with precise file paths and line numbers.

Example code demonstrating protocol-based service registration:

// Protocol definition @protocol WWKUtilityServiceProtocol <NSObject, WWKServiceProtocol> - (std::string)stringSystemConfigForKey:(NSString *)key; @end // Implementation @implementation WWKUtilityService - (std::string)stringSystemConfigForKey:(NSString *)key { return "config"; } @end // Usage [WWKFindService(WWKUtilityServiceProtocol) stringSystemConfigForKey:@"key"];

Plugin Integration

For integrating external plugins (Meeting, Docs, Email), the team developed a shell project approach where Wecom's core capabilities are packaged as a dynamic library (WeComKit). Plugins can call Wecom components through ModuleManager while also registering their own interfaces for other components to use.

The development workflow involves: packaging WeComKit from main project components, developing plugins in the shell project using real Wecom environment and data, then packaging completed plugins as PluginFramework for integration into the main project.