10 good open source HarmonyOS tool library

Hello, I'm V Brother, today I'll share with you 10 good HarmonyOS tool libraries, you can use them when developing Harmony apps, good tools can simplify the code, so you can write elegant apps. Not much to say, immediately open the whole thing.

1. efTool

efTool is a feature-rich and easy to use API12-compliant HarmonyOS tool library , through the use of many utility classes , designed to help developers quickly and easily complete all kinds of development tasks . These packaged tools cover strings , numbers , sets , JSON and a series of operations , can meet a variety of different development needs . I am a Java developer , so the packaging ideas borrowed from the Java tools Hutool, while extending the HarmonyOS UI components.

We use ArkTS (Ark TypeScript) to write ourefTool The sample code for the string tool class in the tool library utilizes these wrappers to simplify development tasks and extend the UI components of HarmonyOS. Suppose we have a string handling tool classStrUtil and an extended UI component.

1. String tool class (`StrUtil`)

//
export default class StrUtil {
  // Determine if a string is empty or contains only whitespace
  static isBlank(input: string): boolean {
    return input == null || () === '';
  }

  // Convert strings to uppercase
  static toUpperCase(input: string): string {
    return input ? () : input;
  }

  // Determines whether a string contains the specified substring
  static contains(input: string, searchString: string): boolean {
    return (searchString) !== -1;
  }
}

2. Examples of extended UI components

//
import { Text, Flex, View } from '@ohos:ohos_ui';

export default class ExtTextComponent {
  // A customized text component，Support for passing in custom styles
  static renderText(content: string, style?: { fontSize?: number; color?: string }) {
    const defaultStyle = {
      fontSize: 16,
      color: '#000000',
    };

    const finalStyle = { ...defaultStyle, ...style };

    return (
      <Text
        value={content}
        fontSize={}
        fontColor={}
      />
    );
  }

  // Used to combine multiple text displays
  static renderTextList(textList: string[], style?: { fontSize?: number; color?: string }) {
    return (
      <Flex direction="column">
        {((text) => (
          <View>
            {(text, style)}
          </View>
        ))}
      </Flex>
    );
  }
}

3. Utilization`StrUtil` and extended`ExtTextComponent`

Below is an example of how to integrate these tools and UI components into a HarmonyOS application:

import StrUtil from './StrUtil';
import ExtTextComponent from './ExtTextComponent';

// sample logic
const content = 'HarmonyOS Tools';
const textList = ['First text', 'Second text', 'Third text'];

function onCreate() {
  const isBlank = (content); // false
  const upperCaseText = (content); // 'HARMONYOS TOOLS'
  const containsHarmony = (content, 'Harmony'); // true

  // Display on the interface
  return (
    <View>
      {(`Is blank: ${isBlank}`)}
      {(`Upper case: ${upperCaseText}`)}
      {(`Contains 'Harmony': ${containsHarmony}`)}
      {(textList)}
    </View>
  );
}

to explain the code:

String Tool ClassesStrUtil: Provides some common string manipulation methods, such as determining whether a string is null, converting to uppercase, and checking whether it contains a substring. These methods are designed to simplify the development of common string handling operations.
Extended UI componentsExtTextComponent: Encapsulates the text presentation logic based on HarmonyOS UI components.renderText method makes it easy to display text with custom styles, while therenderTextList method is further extended to allow batch display of text lists.
Integration Example：onCreate function shows how to utilize theStrUtil cap (a poem)ExtTextComponent Working together, processing logic and dynamically rendering content to the page.

In this way.efTool Not only does it help with basic data type operations such as strings, but it also simplifies interface development tasks by extending the HarmonyOS component library.efToolThere are more great tools to try!

2. harmony-utils

harmony-utils a feature-rich and extremely easy to use HarmonyOS tool library, with the help of a number of utility classes, is committed to helping developers quickly build Harmony applications. Its encapsulated tools cover APP, device, screen, authorization, notifications, inter-thread communication, pop-up boxes, toast, bio-authentication, user preferences, photo, photo albums, scanning, files, logs, exception capture, characters, strings, numbers, sets, dates, random, base64, encryption, decryption, JSON and a series of functions and operations , to meet a variety of different development needs.

We write a program based on ArkTS (Ark TypeScript).harmony-utils sample code from the tool library to show how to use some of these common features.

1. APP Tools (`AppUtil`)

//
export default class AppUtil {
  // Get basic app info
  static getAppInfo() {
    return {
      appName: 'HarmonyApp', version: '1.0.0', {
      
      packageName: '', }
    }; }
  }

  // Exit the app
  static exitApp() {
    // Use the HarmonyOS API to exit the app.
    ('Exiting the app...') ;Call the API to exit the app.
    // Call the API to exit the app, calling system functions if needed.
  }
}

2. Equipment and tools (`DeviceUtil`)

//
export default class DeviceUtil {
  // Getting device information
  static getDeviceInfo() {
    return {
      brand: 'Huawei',
      model: 'P50 Pro',
      osVersion: 'HarmonyOS 3',
    };
  }

  // Getting screen information
  static getScreenInfo() {
    return {
      width: 1080,
      height: 2340,
      density: 2.5,
    };
  }
}

3. Date toolkit (`DateUtil`)

//
export default class DateUtil {
  // Get current date
  static getCurrentDate(): string {
    const date = new Date();
    return ();
  }

  // Formatted Date
  static formatDate(date: Date, format: string): string {
    const options: = {
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
    };
    return new ('en-US', options).format(date);
  }
}

4. Toast tools (`ToastUtil`)

//
export default class ToastUtil {
  // Display short alerts
  static showToastShort(message: string) {
    // utilizationHarmonyOS(used form a nominal expression)Toast API
    (`Short Toast: ${message}`);
  }

  // Displaying long time alerts
  static showToastLong(message: string) {
    // utilizationHarmonyOS(used form a nominal expression)Toast API
    (`Long Toast: ${message}`);
  }
}

5. Utilization`harmony-utils` The tools in the

Here's how to integrate the use ofAppUtil、DeviceUtil、DateUtil cap (a poem)ToastUtil Examples of:

import AppUtil from './AppUtil';
import DeviceUtil from './DeviceUtil';
import DateUtil from './DateUtil';
import ToastUtil from './ToastUtil';

function onCreate() {
  // Getting application information
  const appInfo = ();
  (`App Name: ${}, Version: ${}, Package: ${}`);

  // Getting device information
  const deviceInfo = ();
  (`Device: ${} ${}, OS: ${}`);

  // Getting screen information
  const screenInfo = ();
  (`Screen: ${}x${}, Density: ${}`);

  // Show current date
  const currentDate = ();
  (`Current Date: ${currentDate}`);

  // Show Toast
  ('Welcome to HarmonyOS!');
  
  // Example of exiting the application
  setTimeout(() => {
    ();
  }, 5000); // 5Quit the application after seconds
}

Explain the code:

App Tools (AppUtil): Encapsulates application-related operations that provide functionality for obtaining application information and exiting the application. These operations help developers more easily access application meta-information and control the application lifecycle.
Equipment & Tools (DeviceUtil): Used to obtain basic information about the device (brand, model, OS version) and screen information (resolution and density), allowing developers to adapt the interface design on different devices.
Date Tool Class (DateUtil): Encapsulate the date operation , you can get the current date and format , convenient for developers to deal with time-related logic .
Toast Tools (ToastUtil): Used to display alert messages in applications, simplifies calls to the system toast, and supports two different display modes: short and long.
Integration Example: ByonCreate Methods show how to use these tool classes to obtain application information, device information, display the current date, prompt messages, and exit the application operation. This integration helps developers quickly build functional application logic and simplifies the development process for common tasks.

Through this encapsulation, theharmony-utils Can greatly improve the development efficiency , so that developers can focus on business logic without having to deal with cumbersome basic operations . There are many more great tools for you to use.

3. SpinKit(API12 - 5.0.3.800)

SpinKit is a loading animation library for OpenHarmony/HarmonyOS.

The following was written using ArkTSSpinKit Sample code for loading an animation library. AssumingSpinKit A variety of loading animation styles are provided, and the following example shows how to integrate and use these animations in your application.

1. `SpinKit` Sample Animation Components

//
export default class SpinKit {
  // Circular rotation animation
  static CircleSpinner() {
    return (
      <div>
        <progress-circle
          color="#00BFFF"
          strokeWidth={5}
          radius={30}
        />
      </div>
    );
  }

  // Three bounce point animation
  static ThreeBounceSpinner() {
    return (
      <div>
        <progress-bouncing-dots
          color="#00BFFF"
          dotRadius={10}
          bounceHeight={20}
        />
      </div>
    );
  }

  // Rectangular square loading animation
  static RectangleSpinner() {
    return (
      <div>
        <progress-rectangles
          color="#00BFFF"
          count={5}
          width={10}
          height={30}
          space={5}
        />
      </div>
    );
  }
}

2. Utilization`SpinKit` Loading Animation

Here's how to use it in an ArkTS applicationSpinKit Examples of animations:

import SpinKit from './SpinKit';

function onCreate() {
  // Show different styles of loading animations
  return (
    <View>
      <Text>Circle Spinner:</Text>
      {()}

      <Text>Three Bounce Spinner:</Text>
      {()}

      <Text>Rectangle Spinner:</Text>
      {()}
    </View>
  );
}

Explain:

SpinKit animation component: Encapsulates several common loading animation styles, namely:
- CircleSpinner: Circle rotation loading animation usingprogress-circle tag implementation, setting the color, radius, and line width.
- ThreeBounceSpinner: three bounce point animations using theprogress-bouncing-dots The tag implementation sets the color, the radius of the point, and the height of the bounce.
- RectangleSpinner: Rectangular square loading animation usingprogress-rectangles The tag implementation sets the width and height of the squares, their color, and the spacing between them.
utilizationSpinKit anime: ByonCreate function that renders several loading animations on the page, showing loading animations for circles, bouncing points and rectangular squares, respectively. These animations can be used in different scenarios, such as waiting for a network request or in background task processing.

By encapsulating it in this way, theSpinKit Provides a set of loading animation libraries that developers can easily integrate into HarmonyOS applications to enhance the dynamic interactive experience of the user interface.

4. harmony-dialog

This is an extremely easy to use zero-invasive pop-up windows, just one line of code can be easily realized, wherever you can easily pop-up. It covers AlertDialog, TipsDialog, ConfirmDialog, SelectDialog, CustomContentDialog, TextInputDialog, TextAreaDialog, BottomSheetDialog, ActionSheetDialog, CustomDialog, LoadingDialog, LoadingProgress, Toast, ToastTip and many other types to meet a variety of different pop-up window development needs.

Let's use it and write a sample code based on a popup library written by ArkTS to show how to use these different types of popups such asAlertDialog、ConfirmDialog、Toast etc. The library is designed for zero intrusion , developers only need a line of code can easily realize the effect of pop-up windows .

1. Examples of pop-up libraries (`DialogUtil`)

//
export default class DialogUtil {
  // demonstrateAlertDialog
  static showAlertDialog(title: string, message: string) {
    return (
      <dialog
        type="alert"
        title={title}
        message={message}
        buttonText="OK"
        onButtonClick={() => ('AlertDialog OK clicked')}
      />
    );
  }

  // demonstrateConfirmDialog
  static showConfirmDialog(title: string, message: string, onConfirm: () => void, onCancel: () => void) {
    return (
      <dialog
        type="confirm"
        title={title}
        message={message}
        confirmButtonText="Yes"
        cancelButtonText="No"
        onConfirmClick={onConfirm}
        onCancelClick={onCancel}
      />
    );
  }

  // demonstrateLoadingDialog
  static showLoadingDialog(message: string) {
    return (
      <dialog
        type="loading"
        message={message}
      />
    );
  }

  // demonstrateToastmessages
  static showToast(message: string, duration: number = 2000) {
    setTimeout(() => {
      (`Toast: ${message}`);
    }, duration);
  }

  // demonstrateTextInputDialog
  static showTextInputDialog(title: string, onConfirm: (input: string) => void) {
    let inputValue = '';
    return (
      <dialog
        type="text-input"
        title={title}
        inputHint="Enter text here"
        onConfirmClick={() => onConfirm(inputValue)}
      />
    );
  }
}

2. Utilization`DialogUtil` Popup Window Example

Below is the sample code on how to use these popups in your app:

import DialogUtil from './DialogUtil';

function onCreate() {
  // demonstrateAlertDialog
  const alertDialog = ('Alert', 'This is an alert dialog.');
  
  // demonstrateConfirmDialog
  const confirmDialog = (
    'Confirm',
    'Do you want to continue?',
    () => ('Confirmed'),
    () => ('Cancelled')
  );
  
  // demonstrateLoadingDialog
  const loadingDialog = ('Loading, please wait...');

  // demonstrateToast
  ('This is a toast message');
  
  // demonstrateTextInputDialog
  const textInputDialog = ('Input', (input: string) => {
    (`Input received: ${input}`);
  });
  
  // Render these popups on the interface on demand
  return (
    <View>
      {alertDialog}
      {confirmDialog}
      {loadingDialog}
      {textInputDialog}
    </View>
  );
}

Explain the code:

DialogUtil pop-up library (computing)：
- AlertDialog: A simple alert box with a single "OK" button to display urgent or important information.
- ConfirmDialog: A confirmation box with confirmation and cancel buttons, where the user can choose to confirm or cancel the operation, executing different callback functions respectively.
- LoadingDialog: Used to display progress alerts while loading, often used for network requests or other asynchronous tasks.
- Toast: A short prompt message that disappears automatically, often used to present non-blocking prompts to the user.
- TextInputDialog: A dialog box with a text input box where the user can enter information and confirm it.
usage example：
- existonCreate method, we show how to create and display different types of popups. By calling theDialogUtil The static methods in the can quickly create the desired popup and handle user input or selection.
- Each popup is defined as a separatedialog tag, which can trigger click events or callback functions depending on the user action. For example, clicking on theConfirmDialog in the "Confirm" button, the specified callback function will be executed.

With this encapsulation, we can easily use multiple types of popups and achieve the desired popup effect with just one line of code, simplifying the process of using popups in OpenHarmony/HarmonyOS.

5. PullToRefresh

PullToRefresh is a OpenHarmony environment available in the drop-down refresh , pull-up loading component . Support for setting various properties of the built-in animation , support for setting custom animation , support lazyForEarch data as a data source .

Let's write a program based on ArkTS.PullToRefresh Component sample code to show how to use the component to achieve the function of drop-down refresh and pull-up loading. The component supports built-in animations, custom animations andlazyForEach data source, greatly simplifying the refresh and load operations of the data list.

1. Example of PullToRefresh component ()

//
export default class PullToRefresh {
  private data: Array<string>;
  private loading: boolean;

  constructor() {
     = [];
     = false;
  }

  // Dropdown Refresh Event
  onRefresh(callback: () => void) {
     = true;
    setTimeout(() => {
       = ['New Data 1', 'New Data 2', 'New Data 3'];
       = false;
      callback();
    }, 2000); // analog (device, as opposed digital)2Seconds of network requests
  }

  // Pull-up loading event
  onLoadMore(callback: () => void) {
     = true;
    setTimeout(() => {
      ('More Data 1', 'More Data 2');
       = false;
      callback();
    }, 2000); // analog (device, as opposed digital)2Load more data in seconds
  }

  // Rendering the data list
  renderList() {
    return (
      <lazyForEach items={}>
        {(item) => (
          <list-item>
            <text>{item}</text>
          </list-item>
        )}
      </lazyForEach>
    );
  }

  // Rendering Components
  renderComponent() {
    return (
      <pull-to-refresh
        onRefresh={() => (() => ('Refreshed!'))}
        onLoadMore={() => (() => ('Loaded more!'))}
        refreshing={}
      >
        {()}
      </pull-to-refresh>
    );
  }
}

2. Utilization`PullToRefresh` subassemblies

Here's how to use it in your applicationPullToRefresh Sample code for the component:

import PullToRefresh from './PullToRefresh';

function onCreate() {
  const pullToRefreshComponent = new PullToRefresh();
  
  return (
    <View>
      {()}
    </View>
  );
}

Explain:

Design of the PullToRefresh component：
- data management: The component internally maintains adata array to store the contents of the display via theonRefresh method to refresh the data, through theonLoadMore method to load more data.
- Refresh and load events: The events of drop-down refreshing and drop-up loading are handled by the callback function. Here, a timer is used to simulate a 2-second asynchronous request, and the callback function is called to refresh the interface when it's done.
- Lazy loading of data sources: The component uses thelazyForEach to render a list of data, with each data item starting with alist-item The form of the display. This approach can effectively handle large-scale data and improve rendering performance.
- Animation Support：PullToRefresh The component internally supports built-in animations for dropdown and pullup loading by default, and can be used with therefreshing property controls the loading state.
usage example：
- existonCreate method, we create thePullToRefresh instance of the component, and by calling therenderComponent to render the entire dropdown refresh and pullup load functionality.
- When the user scrolls down to refresh, the component automatically calls theonRefresh event and triggers a callback function to load new data; when the user pulls up to load moreonLoadMore event will be triggered to load more data into the list.

This design combines drop-down refreshing, drop-up loading and dynamic rendering of data to provide an efficient and easy-to-use component solution. In an OpenHarmony environment, developers can easily implement dynamic loading of data through this component, and support custom animation and data rendering methods.

6. ImageKnife

ImageKnife is an image loading cache library built specifically for OpenHarmony, dedicated to being more efficient, lighter and simpler.
Support custom memory cache policy, support setting the size of memory cache (default LRU policy).

Support for disk secondary cache, for downloading pictures will save a copy to disk
Support customized implementation of image acquisition/web download
Support listening to network download callback progress
Inherit the ability of Image, support option pass border, set border, rounded corners
Inherit Image's ability to support option passing objectFit to set image scaling, including objectFit to auto when the height of the image adaptive
Support for scaling images by setting transform
Number of concurrent requests, support for prioritization of request queue queues
Supports images whose life cycle has been destroyed and no longer initiates requests
Customize cache key
Customizing http web request headers
Support writeCacheStrategy to control cache deposit strategy (memory or file cache only).
Support preLoadCache to preload images
Support for onlyRetrieveFromCache only cache loading
Supports the use of one or more image transformations such as blurring, highlighting, etc.

Let's write a program based on ArkTS.ImageKnife Sample code for the Image Load Cache library, showing how to use the library to efficiently load and cache images.ImageKnife Supports custom memory cache policies and allows developers to set the cache size (defaults to LRU policy).

1. `ImageKnife` Library Examples ()

//
class ImageCache {
  private cache: Map<string, string>;
  private maxSize: number;

  constructor(maxSize: number = 10) {
     = new Map<string, string>();
     = maxSize;
  }

  // Get Image
  get(url: string): string | undefined {
    return (url);
  }

  // Storing Images
  set(url: string, image: string) {
    if ( >= ) {
      // Remove the oldest unused images
      const firstKey = ().next().value;
      (firstKey);
    }
    (url, image);
  }
}

export default class ImageKnife {
  private cache: ImageCache;

  constructor(maxSize: number = 10) {
     = new ImageCache(maxSize);
  }

  // Load Image
  loadImage(url: string): Promise<string> {
    return new Promise((resolve, reject) => {
      // 先从缓存中Get Image
      const cachedImage = (url);
      if (cachedImage) {
        resolve(cachedImage);
        return;
      }

      // analog (device, as opposed digital)网络Load Image
      setTimeout(() => {
        const image = `Loaded image from ${url}`; // Simulation of loaded images
        (url, image);
        resolve(image);
      }, 1000); // analog (device, as opposed digital)1Seconds of network requests
    });
  }
}

2. Utilization`ImageKnife` subassemblies

Here's how to use it in your applicationImageKnife Sample code for image loading and caching:

import ImageKnife from '. /ImageKnife';

function onCreate() {
  const imageKnife = new ImageKnife(5); // set the maximum cache size to 5

  // Load the image
  ('/').then((image) => {
    (image); // Output: Loaded image from /
  }).

  // Loaded the same image that should be fetched from the cache
  ('/').then((image) => {
    (image); // Output: Loaded image from / (from cache)
  }).

  // Loaded new image
  ('/').then((image) => {
    (image); // Output: Loaded image from / (from cache) }); // Load new image.
  });
}

Detailed explanation:

ImageCache resemble：
- cache structure: UseMap Stores the URL of the image and the corresponding image data. This structure allows for quick access.
- Maximum Cache Size: BymaxSize property limits the maximum number of caches. When the cache reaches the maximum limit, the longest unused images are removed to make room (implementing a simple LRU policy).
- Acquisition and storage：get method is used to fetch an image from the cache.set method is used to store images into the cache and manage the cache size.
ImageKnife resemble：
- Image Loading：loadImage method is used to load an image. It first checks if the image is already in the cache and returns it directly if it is. If not, it simulates a network request to load the image and store it in the cache.
- asynchronous processing: UsePromise to handle the results of asynchronous loading, making it possible to call the method with the.then() method handles the loading results.
usage example：
- existonCreate method that creates theImageKnife instance and set the maximum cache size to 5.
- When loading an image, the cache is first checked. If the image is already in the cache, it is returned directly; otherwise it will simulate a network request to load the image and store it in the cache.

Through this design, theImageKnife Provides an efficient and simple image loading and caching solution for application development in OpenHarmony environments. Developers can easily set cache policies and sizes to meet different application requirements.

7. mpchart

mpchart various types of chart library , mainly used for business data summary , such as sales data charts , stock price charts and other scenarios used to facilitate the developer to quickly realize the chart UI .

Let's write an ArkTS-basedmpchart Sample code for a charting library showing how to use the library to draw various types of charts, such as sales data charts and stock price charts. This library is designed to help developers quickly implement a charting user interface.

1. `MPChart` Library Examples ()

//
class MPChart {
  private labels: Array<string>;
  private data: Array<number>;
  private type: string;

  constructor(labels: Array<string>, data: Array<number>, type: string = 'line') {
     = labels;
     = data;
     = type;
  }

  // Rendering Charts
  renderChart() {
    switch () {
      case 'line':
        return ();
      case 'bar':
        return ();
      case 'pie':
        return ();
      default:
        return null;
    }
  }

  // Rendering Line Charts
  private renderLineChart() {
    return (
      <view>
        <text>line graph</text>
        <canvas>
          <lineChart
            labels={}
            data={}
            lineColor="#ff5733"
            fillColor="rgba(255, 87, 51, 0.3)"
          />
        </canvas>
      </view>
    );
  }

  // Rendering Bar Charts
  private renderBarChart() {
    return (
      <view>
        <text>histogram</text>
        <canvas>
          <barChart
            labels={}
            data={}
            barColor="#33c1ff"
          />
        </canvas>
      </view>
    );
  }

  // rendering pie chart
  private renderPieChart() {
    return (
      <view>
        <text>pie chart</text>
        <canvas>
          <pieChart
            labels={}
            data={}
            colors={['#ff6384', '#36a2eb', '#cc65fe']}
          />
        </canvas>
      </view>
    );
  }
}

2. Utilization`MPChart` subassemblies

Here's how to use it in your applicationMPChart to draw different types of chart sample code:

import MPChart from './MPChart';

function onCreate() {
  const labels = ['January', 'February', 'March', 'April', 'May'];
  const salesData = [30, 50, 70, 40, 90]; // Sales data
  const priceData = [100, 120, 80, 130, 110]; // Stock price data

  return (
    <view>
      {/* 渲染Sales data折线图 */}
      <MPChart labels={labels} data={salesData} type="line" />

      {/* 渲染Stock price data柱状图 */}
      <MPChart labels={labels} data={priceData} type="bar" />

      {/* 渲染Sales data饼图 */}
      <MPChart labels={labels} data={salesData} type="pie" />
    </view>
  );
}

Explain the code:

MPChart resemble：
- constructor: Receive labels, data, and types of charts (e.g., line charts, bar charts, pie charts).
- renderChart methodologies: Calls the appropriate rendering method based on the chart type.
- Rendering Methods：
  - renderLineChart: Renders a line graph using thelineChart Component.
  - renderBarChart: Renders a bar chart using thebarChart Component.
  - renderPieChart: Renders a pie chart using thepieChart Component.
usage example：
- existonCreate method, we define a set of labels and corresponding sales data and stock price data.
- utilizationMPChart The component renders a line chart of sales data, a bar chart of stock price data, and a pie chart of sales data, respectively.

This design allows developers to quickly implement multiple types of charts, simplifying the charting process and making it easy to switch between different chart types by changing parameters.mpchart The library's flexibility and ease of use make it ideal for visualizing business data.

8. Zxing

Zxing is a three-way component for parsing and generating 1D and 2D codes for declarative application development, supporting the parsing and generation of a variety of 1D and 2D codes.

Let's write a program based on ArkTS.Zxing Component sample code to show how to use the component to generate and parse the two-dimensional code and one-dimensional code.Zxing is a powerful tool widely used for the creation and interpretation of QR codes and barcodes.

1. `Zxing` Library Examples ()

//
import { QRCode } from 'zxing-js'; // Suppose that the introduction ofZXingRelated libraries

export default class Zxing {
  // Generate QR code
  static generateQRCode(data: string, size: number = 256): string {
    const qrCode = new QRCode();
    ('L'); // Setting the Error Correction Level
    (1); // Setting Margins

    return (data, {
      width: size,
      height: size,
      color: {
        dark: '#000000', // QR Code Color
        light: '#ffffff', // background color
      },
    });
  }

  // Parsing QR codes
  static async decodeQRCode(image: string): Promise<string | null> {
    const qrCodeReader = new QRCode();
    try {
      const result = await (image);
      return result; // Returns the decoded content
    } catch (error) {
      ('Failed to decode:', error);
      return null; // Failed to decode返回null
    }
  }
}

2. Utilization`Zxing` subassemblies

Here's how to use it in your applicationZxing to generate and parse the QR code sample code:

import Zxing from '. /Zxing';

function onCreate() {
  const qrData = "Hello, Zxing!"; // the data to be encoded
  const qrCodeImage = (qrData); // Generate the data URL for the QR code

  // Display the QR code
  ('QR code generated successfully:', qrCodeImage); // Display the QR code.

  // Assuming you got the QR code image data from somewhere to decode it
  const qrCodeToDecode = qrCodeImage; // the actual image should be passed in the real scene

  // Parsing the QR code
  (qrCodeToDecode).then((result) => {
    if (result) {
      ('Decoding result:', result); // output the decoding result
    } else {
      ('Decoding failed'); }
    }
  });
}

Explain the code:

Zxing resemble：
- generateQRCode methodologies：
  - This method is used to generate a QR code, accepting as parameters the data to be encoded and the size of the QR code.
  - utilizationQRCode class creates a QR code and sets the error correction level and margins.
  - Returns the generated QR code data URL, which can be used directly in the<img> tabbedsrc Properties.
- decodeQRCode methodologies：
  - Asynchronously parses the incoming QR code image data and returns the decoded content.
  - If decoding fails, returnnull。
usage example：
- existonCreate method, first define the string to be encoded and then call thegenerateQRCode method generates the image data URL of the QR code.
- The generated QR code image can be displayed on the user interface (e.g. via the<img> (Labeling).
- subsequent callsdecodeQRCode method parses the QR code and outputs the decoded result.

Through this design, theZxing The component provides developers with convenient QR code and barcode generation and parsing functionality, simplifying related operations and making declarative application development more efficient.

9. ijkplayer

ijkplayer is an FFmpeg-based video player available in the OpenHarmony environment.

Let's write a program based on ArkTS.ijkplayer Sample code showing how to use an FFmpeg-based video player in an OpenHarmony environmentijkplayer。ijkplayer is a powerful player that supports video playback in multiple formats and is suitable for developing rich multimedia applications.

1. `IJKPlayer` Component Examples ()

//
import { Player } from 'ijkplayer-js'; // Assuming that ijkplayer-related libraries are introduced.

export default class IJKPlayer {
  private player: Player; }

  constructor(videoUrl: string) {
     = new Player(); // Create a player instance.
    (videoUrl); // Set the video source.
  }

  // Play the video
  play() {
    ().then(() => {
      (); // Start playing when ready
    }).catch(error => {
      ('Playback failed:', error);
    });
  }

  // Pause the video
  pause() {
    (); }
  }

  // Stop the video
  stop() {
    (); }
  }

  // Set the video to full screen
  setFullScreen() {
    (true); }
  }

  // Destroy the player
  release() {
    (); }
  }
}

2. Utilization`IJKPlayer` subassemblies

Here's how to use it in your applicationIJKPlayer Sample code for playing a video:

import IJKPlayer from '. /IJKPlayer';

function onCreate() {
  const videoUrl = '/video.mp4'; // video source address
  const player = new IJKPlayer(videoUrl); // create the player instance

  // Play the video
  ();

  // Suppose at some point you want to pause the playback
  setTimeout(() => {
    ();
    ('Video has been paused'); }, 5000); // Pause after 5 seconds.
  }, 5000); // pause after 5 seconds

  // Assuming at some point you want to stop playback
  setTimeout(() => {
    ();
    ('Video has stopped'); // Release the player.
    (); // Free up player resources
  }, 10000); // stop after 10 seconds
}

Explain the code:

IJKPlayer resemble：
- constructor: Receive the video URL and createPlayer Example of setting up a video source.
- play methodologies: Prepare the video and start playback. Use theprepare method preloads the video, and upon success calls thestart method to start playback and output an error message when it fails.
- pause methodologies: Calls the player'spause method to pause video playback.
- stop methodologies: Calls the player'sstop method to stop video playback.
- setFullScreen methodologies: Set the video to play in full screen.
- release methodologies: Release player resources to avoid memory leaks.
usage example：
- existonCreate method, define the URL of the video and create theIJKPlayer Example.
- call (programming)play method to start playing the video.
- utilizationsetTimeout The simulation pauses video playback after 5 seconds and stops playback and releases player resources after 10 seconds.

Through this design, theijkplayer Provides a simple and effective way to play video for multimedia application development in the OpenHarmony environment. Developers can add more features as needed, such as controlling volume, playback progress, switching video sources, and more.

10. pinyin4js

pinyin4js adapts OpenHarmony, a Chinese character-to-pinyin Javascript open source library, with the following features.

zero dependency
Flexible importation and packaging of thesaurus
You can adjust the dictionary by yourself, you can refer to src/dict; all resource calls are encapsulated by PinyinResource, you can modify and package them by yourself
Accurate and complete font
Unicode code from 4E00-9FA5 range and 3007 (〇) of 20903 Chinese characters, pinyin4js can convert all Chinese characters except 46 variant characters (variant characters do not exist in the standard pinyin).
Fast pinyin conversion speed
Tested, from 4E00-9FA5 range of 20902 Chinese characters, pinyin4js took about 110 milliseconds
Multi-pinyin format output support
Supports multiple pinyin output formats: with phonetic symbols, without phonetic symbols, numeric representation of phonetic symbols, and pinyin initials.
Recognition of common polyphonic characters
Supports recognition of common polyphonic characters, including phrases, idioms, place names, etc.
Convert Simplified Chinese to Traditional Chinese
Support for adding custom dictionaries

Let's write a program based on ArkTS.pinyin4js Sample code to show how to use this library to convert Chinese characters to Pinyin in an OpenHarmony environment.pinyin4js is an open source library that provides Chinese character to pinyin conversion, ideal for applications that need to work with Chinese text.

1. `Pinyin4js` Component Examples ()

//
import { PinyinHelper } from 'pinyin4js'; // Suppose that the introduction ofpinyin4jsRelated libraries

export default class PinyinConverter {
  // convert from Chinese characters to pinyin
  static convertToPinyin(input: string): string[] {
    const pinyinArray = (input, "", PinyinHelper.WITH_TONE_MARK); // pinyin (Chinese romanization)
    return (','); // Returns a pinyin array
  }
}

2. Utilization`PinyinConverter` subassemblies

Here's how to use it in your applicationPinyinConverter Sample code for converting Chinese characters to Pinyin:

import PinyinConverter from '. /Pinyin4js';

function onCreate() {
  const chineseText = 'Convert Chinese character to pinyin'; // Chinese character to be converted
  const pinyinArray = (chineseText); // Convert to pinyin.

  ('Original text:', chineseText); // Convert to pinyin.
  ('Pinyin:', (', ')); // output pinyin
}

Explain the code:

PinyinConverter resemble：
- convertToPinyin methodologies：
  - Receives a string of Chinese characters as input, using the method converts it to a pinyin string.
  - convertToPinyinString The parameter description of the
    - The first parameter is the Chinese character string to be converted.
    - The second argument is the concatenator, here the empty string ("") indicates that no connectors are used between pinyin.
    - The third parameter specifies the format of pinyin, here we choosePinyinHelper.WITH_TONE_MARK Return in phonetic form with tones.
  - Finally, split the pinyin string by comma and return the pinyin array.
usage example：
- existonCreate method, define the Chinese character string to be converted, and then call theconvertToPinyin method to perform the conversion.
- Output the original and converted pinyin.

Through this design, thepinyin4js Provides an easy way to handle conversions between Chinese characters and Pinyin, ideal for use in applications involving Chinese text, and developers can extend or modify it as needed.

ultimate

HarmonyOS NEXT official version will be released soon, you are learning the process of Hongmeng what other good use of the tool library, welcome to share with the V brother, pay attention to the Wei brother love programming, together to learn the development of Hongmeng.

10 good open source HarmonyOS tool library

1. efTool

1. String tool class (StrUtil)

2. Examples of extended UI components

3. UtilizationStrUtil and extendedExtTextComponent

to explain the code:

2. harmony-utils

1. APP Tools (AppUtil)

2. Equipment and tools (DeviceUtil)

3. Date toolkit (DateUtil)

4. Toast tools (ToastUtil)

5. Utilizationharmony-utils The tools in the

Explain the code:

3. SpinKit(API12 - 5.0.3.800)

1. SpinKit Sample Animation Components

2. UtilizationSpinKit Loading Animation

Explain:

4. harmony-dialog

1. Examples of pop-up libraries (DialogUtil)

2. UtilizationDialogUtil Popup Window Example

Explain the code:

5. PullToRefresh

1. Example of PullToRefresh component ()

2. UtilizationPullToRefresh subassemblies

Explain:

6. ImageKnife

1. ImageKnife Library Examples ()

2. UtilizationImageKnife subassemblies

Detailed explanation:

7. mpchart

1. MPChart Library Examples ()

2. UtilizationMPChart subassemblies

Explain the code:

8. Zxing

1. Zxing Library Examples ()

2. UtilizationZxing subassemblies

Explain the code:

9. ijkplayer

1. IJKPlayer Component Examples ()

2. UtilizationIJKPlayer subassemblies

Explain the code:

10. pinyin4js

1. Pinyin4js Component Examples ()

2. UtilizationPinyinConverter subassemblies

Explain the code:

ultimate

1. String tool class (`StrUtil`)

3. Utilization`StrUtil` and extended`ExtTextComponent`

1. APP Tools (`AppUtil`)

2. Equipment and tools (`DeviceUtil`)

3. Date toolkit (`DateUtil`)

4. Toast tools (`ToastUtil`)

5. Utilization`harmony-utils` The tools in the

1. `SpinKit` Sample Animation Components

2. Utilization`SpinKit` Loading Animation

1. Examples of pop-up libraries (`DialogUtil`)

2. Utilization`DialogUtil` Popup Window Example

2. Utilization`PullToRefresh` subassemblies

1. `ImageKnife` Library Examples ()

2. Utilization`ImageKnife` subassemblies

1. `MPChart` Library Examples ()

2. Utilization`MPChart` subassemblies

1. `Zxing` Library Examples ()

2. Utilization`Zxing` subassemblies

1. `IJKPlayer` Component Examples ()

2. Utilization`IJKPlayer` subassemblies

1. `Pinyin4js` Component Examples ()

2. Utilization`PinyinConverter` subassemblies