Input Method Function Adaptation in Basic Mode and Full Experience Mode in HarmonyOS

This article aims to deeply discuss the technical details of function adaptation of high-security input methods in basic mode and full experience mode and is summarized based on actual development practices. Mainly serving as a carrier for technical sharing and exchange, it is inevitable that there may be errors and omissions. Colleagues are welcome to put forward valuable opinions and questions for common progress. This article is original content. Any form of reprint must indicate the source and original author.

In today's digital environment, user data security is of utmost importance. As a tool frequently used by users, input methods must ensure that they can provide a good functional experience and guarantee data security in different modes. This article will introduce in detail how to design and implement an input method application in the Huawei HarmonyOS Next system (API 12) to make it perfectly adapt to basic mode and full experience mode, including aspects such as project requirement analysis, architecture design, key technology implementation, and shared sandbox data security control.

I. Project Requirements and Architecture Design

(I) Application Scenario Analysis of Security Modes

In basic mode, the input method needs to strictly abide by privacy and data protection regulations and prohibit accessing system capabilities that may involve user privacy, such as networks, text messages, and positioning. This is mainly applied in scenarios with extremely high security requirements, such as enterprise internal office environments, to prevent the risk of user data leakage. The full experience mode provides more abundant functions and allows the use of networks and access to user data interfaces to enhance the user experience and is suitable for daily use scenarios of ordinary users.

(II) Architecture Design

We adopt a modular architecture design and divide the input method functions into basic function modules and extended function modules. The basic function module can run in both basic mode and full experience mode, including basic functions such as input and display. The extended function module is adapted according to different modes and is disabled in basic mode and enabled in full experience mode, such as functions like network search and personalized recommendation. At the same time, a security detection module is introduced. The getSecurityMode method of IME Kit is used to detect the current running mode and dynamically adjust the input method functions.

II. Function Adaptation in Basic Mode

(I) Use getSecurityMode to Check the Current Mode

In the initialization stage of the input method application, call the getSecurityMode method to obtain the current security mode. The following is a simple example code:

import { inputMethod } from '@kit.IMEKit';

async function checkSecurityMode() {
  let securityMode = await inputMethod.getSecurityMode();
  if (securityMode === 'basic') {
    // Function adaptation in basic mode
  } else if (securityMode === 'full') {
    // Function adaptation in full experience mode
  }
}

(II) Disable All Network Requests and Data Transmissions in Basic Mode to Ensure Data Isolation

In basic mode, we need to ensure that the input method does not make any network requests to prevent data leakage. This can be achieved through code-level restrictions. For example:

if (isBasicMode) {
  // Disable all network-related operations
  disableNetworkRequests();
  // Ensure that data is not transmitted externally
  isolateData();
}

Here, the disableNetworkRequests and isolateData functions need to be implemented according to specific business logic and system interfaces. For example, you can disable the use of network libraries and limit data access permissions.

III. Function Expansion in Full Experience Mode

(I) Enable Networks and User Data Interfaces to Enhance User Experience

In full experience mode, we can enable network requests to implement some advanced functions, such as online dictionary update and cloud input. At the same time, we can access user data interfaces to provide personalized input suggestions based on the user's historical input habits. For example:

if (isFullMode) {
  // Enable network requests
  enableNetworkRequests();
  // Access the user data interface to obtain personalized suggestions
  const personalizedSuggestions = getUserDataSuggestions();
  // Apply personalized suggestions to the input method
  applySuggestions(personalizedSuggestions);
}

(II) Implement Dynamic Mode Detection and Switching to Ensure the Input Method Adjusts Functions When the Mode is Switched

To ensure that the input method can adjust functions in time when the system security mode is switched, we need to listen to mode changes in real time. This can be achieved by registering a mode change listener. For example:

inputMethod.on('securityModeChange', (newMode) => {
  if (newMode === 'basic') {
    // Switch to basic mode and disable related functions
    disableFullModeFeatures();
  } else if (newMode === 'full') {
    // Switch to full experience mode and enable related functions
    enableFullModeFeatures();
  }
});

IV. Security Control of Shared Sandbox Data

(I) Implement Read-Only Access to Shared Sandbox in Basic Mode

In basic mode, to prevent data from being accidentally modified or leaked, we set the shared sandbox to read-only access. This can be achieved through file system permission settings or specific sandbox access interfaces. For example:

if (isBasicMode) {
  setSharedSandboxReadOnly();
}

(II) In Full Experience Mode, Ensure the Security of Data Transmission in the Shared Sandbox

In full experience mode, although the shared sandbox can be read and written, we still need to ensure the security of data transmission. Encryption technology can be used to encrypt and store and transmit data in the shared sandbox. For example:

if (isFullMode) {
  encryptSharedSandboxData();
  // Decrypt the data when reading the data
  const decryptedData = decryptSharedSandboxData();
}

V. Sample Code and Security Architecture Diagram

(I) Sample Code

The following is a simplified security code example for basic mode and full experience mode:

import { inputMethod } from '@kit.IMEKit';

// Check the current security mode
async function checkSecurityMode() {
  let securityMode = await inputMethod.getSecurityMode();
  return securityMode;
}

// Function adaptation in basic mode
function adaptToBasicMode() {
  // Disable network requests
  disableNetworkRequests();
  // Set shared sandbox to read-only
  setSharedSandboxReadOnly();
}

// Function expansion in full experience mode
function adaptToFullMode() {
  // Enable network requests
  enableNetworkRequests();
  // Encrypt shared sandbox data
  encryptSharedSandboxData();
}

// Mode change listener
function registerSecurityModeChangeListener() {
  inputMethod.on('securityModeChange', (newMode) => {
    if (newMode === 'basic') {
      adaptToBasicMode();
    } else if (newMode === 'full') {
      adaptToFullMode();
    }
  });
}

// Function to disable network requests (example, needs to be implemented according to the specific network library)
function disableNetworkRequests() {
  // Assuming the network library has a global disable method
  networkLib.disableAllRequests();
}

// Function to set shared sandbox to read-only (example, needs to be implemented according to the actual sandbox interface)
function setSharedSandboxReadOnly() {
  sharedSandbox.setReadOnly(true);
}

// Function to enable network requests (example, implemented according to the network library)
function enableNetworkRequests() {
  networkLib.enableRequests();
}

// Function to encrypt shared sandbox data (example, needs to be implemented using an encryption library)
function encryptSharedSandboxData() {
  const data = getSharedSandboxData();
  const encryptedData = encryptData(data);
  saveEncryptedData(encryptedData);
}

(II) Security Architecture Diagram and Mode Detection

Security Architecture Diagram:

Mode Detection Flowchart:

1. The input method application starts.
2. Call the checkSecurityMode function to obtain the current security mode.
3. If it is basic mode, execute the adaptToBasicMode function for function adaptation; if it is full experience mode, execute the adaptToFullMode function.
4. Register the securityModeChange listener to listen to mode changes in real time.
5. When the system security mode changes, the listener is triggered, and the corresponding adaptation function is executed again according to the new mode.

Through the above design and implementation, we have successfully created a high-security input method application that can run stably in basic mode and full experience mode, ensuring user data security while providing a good functional experience. In actual development, the security mechanism can be further optimized, more security detection points can be added, and function adaptation details can be improved. I hope this article can provide useful references and inspiration for security-related work in the development of input methods in the HarmonyOS system.