Previous review

In a previous blog post , We introduced OpenHarmony Structure of module 2 , It also roughly expounds that Provider and Consumer It is the relationship between the server and the client of the main role . At the same time, we also introduced samgr_client The function implementation process of the client with file as the object .

All the contents are reviewed as follows ：

OpenHarmony Preliminary analysis of module 2
OpenHarmony Preliminary analysis of module 2 （2）
Those things about the client
What happened to the client （2）

Functional analysis

Function encapsulation

The code of the file begins with two function encapsulation , Respectively SamgrServer and ProcFunc Two function packages .
The code is as follows ：

static SamgrServer g_server = {
    
    .GetName = GetName, // Get the name of a service element 
    .Initialize = Initialize,   // initialization 
    .GetTaskConfig = GetTaskConfig, // Define the task configuration of the service 
    .MessageHandle = MessageHandle, // Processing service messages 
    SERVER_IPROXY_IMPL_BEGIN,   // Defines the start of the default initialization of the server proxy class .
        // This macro is used to develop the server proxy class , You can inherit this macro to reduce the amount of code and prevent inconsistent class definitions .

    .Invoke = Invoke,   // From the client to IServerProxy send out IPC news 
    IPROXY_END,
};

static ProcFunc g_functions[] = {
       // Process function 
    [RES_ENDPOINT] = ProcEndpoint,  // Process terminal 
    [RES_FEATURE] = ProcFeature,    // Process characteristics 
    [RES_SYSCAP] = ProcSysCap,      // Process system capability 
};

When encapsulating functions , The functions encapsulated in the package are not immediately executed , Instead, execute at the time of the call , These two function packages will often be called in subsequent function functions .
Now briefly introduce the function implementation process of the encapsulated function ：

GetName

This function calls a pointer service, Return to one SAMGR_SERVICE, This pointer points to the service that needs to be obtained

Initialize

Initialization operation , It mainly initializes the service and identity invoked by the user , The function of adding router is called in this function , At the same time, the user's identity 、 The pointer to the called function returns null , A new space is reapplied for storing the identity of the new user and the new pointer to the called function , So as to achieve the initialization operation .

GetTaskConfig

The function of this function is to define the task configuration of the service , In this function , We can see that it calls a TaskConfig function

static TaskConfig GetTaskConfig(Service *service)   // Define the task configuration of the service , Used to get task management 
{
    
    (void)service;
    // Can't be used directly PRI_BUTT, As a result, less 1
    TaskConfig config = {
    LEVEL_HIGH, PRI_BUTT - 1, 0x400, 20, SINGLE_TASK}; // Cannot use PRI_BUTT directly, so minus 1
    return config;
}

This function defines five contents , as follows ：

struct TaskConfig {
    

    int16 level;  // Multi service shared tasks ID.
    int16 priority;  // Task priority .
    uint16 stackSize;   // The size of the task stack 
    uint16 queueSize;   // The size of the task queue 
    uint8 taskFlags;    // Task type .
};
#pragma pack()

Therefore, defining the task configuration of services mainly starts with defining five task configurations ：

• Multi service shared tasks ID
• Task priority
• The size of the task stack
• The size of the task queue
• Task type

MessageHandle

Processing service messages , First open the mutex , And then call SASTORA_ClearByPid adopt Pid Remove old （ After use ） User service information , Close the mutex after these steps

static BOOL MessageHandle(Service *service, Request *request)   // Processing service messages 
{
    
    SamgrServer *server = (SamgrServer *)service;
    switch (request->msgId) {
    
        case MSG_CLEAN:
            MUTEX_Lock(server->mtx);    // The mutex 
            SASTORA_ClearByPid(&server->store, request->msgValue);  // adopt Pid eliminate 
            MUTEX_Unlock(server->mtx);  // Mutually exclusive unlock 
            break;
        default:
            break;
    }
    return TRUE;
}

ProcEndpoint

Process terminal , Node used to set the end of the process .
Implementation process ： First get a call pid, Then open the mutex , Through the pid Find a handle to store , Then through a service handle , Get call Tid And call uid, Re pass Pid Preservation processing , Logout death callback , Close mutex .

You can use a simple flow chart to describe ：

ProcFeature

Process characteristics , This function is used to detect whether the characteristic value is set successfully . In the function , According to different conditions Get three different features ：
①IPC Authentication interface ;② Process output characteristics ;③ Process acquisition characteristics
The functions and implementation processes of these features will be introduced later

ProcSysCap

This function is used to test the system capability , First call CanRequest Function to judge and check , Do not give permission when the conditions are met . If the customer gets permission , The following test functions can be performed ：
① Process adds system capabilities （ProcAddSysCap）
② Processes acquire system capabilities （ProcGetSysCap）
③ The process acquires all system capabilities （ProcGetAllSysCap）
The implementation process of these functions will also be introduced in subsequent blogs

Next up

In the next issue, we will introduce the implementation process of some functions mentioned in this blog , In addition samgr_server Functions of other functions under the file .
What if you want to know what happened , Let's hear the decomposition next time

Related blog

OpenHarmony File under module 2 samgr_server analysis （1）
OpenHarmony File under module 2 samgr_server analysis （2）
OpenHarmony File under module 2 samgr_server analysis （3）
OpenHarmony File under module 2 samgr_server analysis （4）
OpenHarmony File under module 2 samgr_server analysis （5）