DEV Community: HarmonyOS

How to Solve the Issue of prevMargin nextMargin Properties Not Taking Effect in Swiper ?

HarmonyOS — Mon, 28 Sep 2026 01:24:00 +0000

Read the original article：How to Solve the Issue of prevMargin nextMargin Properties Not Taking Effect in Swiper ?

Problem Description

The nextMargin and prevMargin parameters are set to display three items on each page. After an application is exited and then returned to, the items on the left and right sides are not displayed.

Background Knowledge

The onAreaChange callback is triggered when the component area changes, and can be used to obtain the component's width and height..

Swiper is a slider view container that enables the child components to be displayed in a carousel manner. For details about the size attributes of Swiper, see Layout and constraints.

displayCount Sets the number of elements displayed in the Swiper view.
nextMargin Set the bottom margin to reveal a small portion of the next item.
prevMargin Set the top margin to reveal a small portion of the previous item.

PrevMargin and nextMargin usage restrictions: When the main axis direction is set to horizontal or vertical, if either nextMargin or prevMargin is greater than the width or height of the child component, neither nextMargin nor prevMargin will be displayed.

Solution

In Swiper, if you do not use displayCount to set the number of items to be displayed, the width of each page that the Swiper component slides is the width of the Swiper component by default. That is, the width of the child component is the same as that of the parent Swiper component.
When prevMargin/nextMargin is used to set the display of the previous and next items, the width of the child component is reduced. For example, if 100 vp is set for the previous and next items, the width of the child component is the width of the Swiper minus 200 vp.
Use prevMargin/nextMargin to display three items in the Swiper. To prevent the set value from being greater than the width and height of the child component and causing the setting to become invalid, you can use onAreaChange to obtain the width and height of the parent component Swiper, and accurately control the part where the previous and next items are displayed based on the width and height of the Swiper.

The following is an example code: Obtain the width of the Swiper swiperWidth, and set prevMargin and nextMargin to one third of swiperWidth. In this case, the width of the child component is also one third of the Swiper.

import { common } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';

@Entry
@Component
struct SwiperMargin {
  private swiperController: SwiperController = new SwiperController();
  @State swiperHeight: number = 0;
  @State swiperWidth: number = 0;
  private data: number[] = [];
  @State currentIndex: number = 1;

  aboutToAppear(): void {
    for (let i = 1; i <= 10; i++) {
      this.data.push(i);
    }
  }

  onPageShow(): void {
    let context = this.getUIContext().getHostContext() as common.UIAbilityContext;
    window.getLastWindow(context).then((lastWindow) => {
      lastWindow.setPreferredOrientation(window.Orientation.LANDSCAPE);
    });
    const routerParams = this.getUIContext().getRouter().getParams() as Record<string, number>;
    if (routerParams !== undefined && routerParams !== null) {
      console.info(`test ${routerParams.data2}`);
      this.swiperController.changeIndex(routerParams.data2);
    }
  }

  build() {
    Column() {
      Row({ space: 12 }) {
        Text(`Currently on page ${this.currentIndex + 1}, out of ${this.data.length} pages.`)
          .margin({top: 24, left: 48, right: 48})
      }
      .onClick(() => {
        this.getUIContext().getRouter().pushUrl({
          url: 'pages/Page', params: {
            data1: this.currentIndex + 1
          }
        });
      });

      Swiper(this.swiperController) {
        ForEach(this.data, (item: string) => {
          Text(item.toString())
            .margin({ top: 10, bottom: 10})
            .height('25%')
            .backgroundColor(0xAFEEEE)
            .textAlign(TextAlign.Center)
            .fontSize(30);
        }, (item: string) => item);
      }
      .vertical(true)
      .width('80%')
      .height('90%')
      .loop(false)
      .index($$this.currentIndex)
      .indicator(true)
      .loop(false)
      .duration(1000)
      .itemSpace(0)
      .onChange((number) => {
        this.currentIndex = number;
      })
      .onAreaChange((_: Area, newValue: Area) => {
        this.swiperHeight = newValue.height as number;
        this.swiperWidth = newValue.width as number;
      })
      .nextMargin(this.swiperHeight / 3)
      .prevMargin(this.swiperHeight / 3);
    }
    .justifyContent(FlexAlign.Center)
    .width('100%')
  }
}
import { window } from '@kit.ArkUI';
import { common } from '@kit.AbilityKit';

@Entry
@Component
struct Page {
  message: string = 'Hello World';
  @State parm: number = 0;

  aboutToAppear(): void {
    let context = this.getUIContext().getHostContext() as common.UIAbilityContext;
    window.getLastWindow(context).then((lastWindow) => {
      lastWindow.setPreferredOrientation(window.Orientation.PORTRAIT);
    });
    const routerParams = this.getUIContext().getRouter().getParams() as Record<string, number>;
    if (routerParams !== undefined && routerParams !== null) {
      this.parm = routerParams.data1;
    } else {
      this.parm = -1;
    }
  }

  build() {
    RelativeContainer() {
      Text(`${this.message}${this.parm}`)
        .id('PageHelloWorld')
        .fontSize(50)
        .fontWeight(FontWeight.Bold)
        .alignRules({
          center: { anchor: '__container__', align: VerticalAlign.Center },
          middle: { anchor: '__container__', align: HorizontalAlign.Center }
        })
        .onClick(() => {
          this.getUIContext().getRouter().back({
            url: 'pages/SwiperMargin',
            params: {
              data2: this.parm - 1
            }
          });
        });
    }
    .height('100%')
    .width('100%');
  }
}

Verification Result

Q: Why do the prevMargin ('10%') and nextMargin ('10%') settings for Swiper not take effect?

A: The top and bottom margins cannot be set to percentages.

Written by Egemen Ayhan

How to Fix Targeted Push Issues in Listing Review

HarmonyOS — Mon, 28 Sep 2026 01:21:00 +0000

Read the original article：How to Fix Targeted Push Issues in Listing Review

Problem Description

When submitting an app update for release on the AppGallery, AGC feedback stated:
“Your app contains a targeted push feature but does not prominently indicate the targeted push service within the app.”
How should this targeted push issue in the rejection notice be resolved?

Your app explicitly contains a targeted push function but does not meet the following requirements: clearly stating the targeted push function in the privacy policy, prominently labeling the targeted push service in the app, and providing an option to disable it. This violates item 7.7 of the Huawei AppGallery Review Guidelines.

Background Knowledge

Targeted Push:
This refers to activities that recommend or display content, provide search results, or push commercial advertisements to an individual based on their personal information such as browsing history, interests, consumption records, and habits. In business practice, targeted push is also referred to as personalized display or personalized recommendation.

If an app has a targeted push feature, it must meet the following three criteria:

Clearly state the targeted push feature in the privacy policy.
Prominently label the targeted push service in the app.
Provide an option to disable the targeted push service.

Troubleshooting Process

If the app contains a targeted push feature, ensure the following three requirements are met:
a. Clearly indicate the presence of a targeted push feature in the in-app privacy policy and in the privacy policy URL submitted on AppGallery Connect.
b. Prominently label the targeted push service in the app.
c. Provide an option to disable the targeted push service.
If the app does not contain a targeted push feature, remove all content that may suggest otherwise, including:
a. The in-app privacy policy.
b. The privacy policy URL submitted on AppGallery Connect.
c. Any relevant in-app pages.
Note: Prominent differentiation of a targeted push service includes but is not limited to the use of terms such as “Personalized Recommendation,” “Recommended for You,” or “You May Like,” and other similar noticeable phrases.

Solution

If the app actually includes targeted push functionality:

That is, some features display different content to different users based on their browsing history, interests, consumption records, or habits:

State the targeted push function in the privacy policy: Clearly explain which information is collected for targeted push, e.g., “XX App includes a targeted push feature that collects your XX information to recommend products or services that may interest you.” If the app uses personal data from third parties for targeted push, the third-party data source must also be clearly stated.
Prominently label the targeted push service within the app: Clearly differentiate targeted push services within the app. Methods include labeling with terms such as “Personalized Recommendation,” “Targeted Push,” “You May Like,” or by displaying them in separate columns, sections, or pages.
Provide an option to disable the targeted push service: If targeted push exists, users must be given a convenient option to opt out or disable the personalized display mode. Once a user opts out or disables this feature, their personal data must not continue to be used for targeted push or precise marketing.

If the app does not include targeted push functionality:

Review the privacy policy and remove any references to “personalized recommendations,” “personalized services,” “targeted push,” etc.
Check whether there are features named “Personalized Recommendation,” “Recommendation,” “Targeted Push,” or “You May Like.” If these sections display the same content for all users (i.e., not personalized), rename them to neutral terms like “Hot,” “Trending,” or “Top List.”
The app does not need to provide an option to disable personalized display features.
When resubmitting for review, include a note stating: “We have confirmed that the app does not contain any targeted push functionality.”

If you disagree with the review result, you may appeal through the Interactive Center.

Verification Result

Q: The app was rejected for “not providing an in-app option to disable targeted push,” but our settings page already has a “Push Notifications” toggle. Is that acceptable?

A: No. The “Push Notifications” toggle does not clearly relate to targeted push.
It’s recommended to use wording that explicitly distinguishes the targeted push service, or name the toggle consistently with the in-app module (e.g., if the app has a “You May Like” section, the toggle should be named “You May Like” switch).

Q: The “Merchant Recommendations” section is just a feature name and does not actually use targeted push. Do we still need to include targeted push descriptions in the privacy policy and add a toggle?

A: No.
If the content displayed in this module is the same for all users (i.e., not personalized), you can rename it to something less confusing like “Hot Products.”
If there’s no targeted push functionality, you do not need to mention it in the privacy policy or add a targeted push toggle.

If the app includes targeted push capability, it must meet all three key requirements — missing any one will result in rejection.
If the app does not include targeted push capability, avoid using confusing terms such as “Personalized Recommendation,” “Recommendation,” “Targeted Push,” or “You May Like,” and remove any mention of targeted push from the privacy policy.

Written by Egemen Ayhan

How to Resolve the Issue of Base64Helper Inheritance Not Working in Mock

HarmonyOS — Mon, 28 Sep 2026 01:08:00 +0000

Read the original article：How to Resolve the Issue of Base64Helper Inheritance Not Working in Mock

Problem Description

The inheritance of Base64Helper in the mock does not take effect.
The code is as follows:

// Base64HelperMock.mock.ets
import { util } from '@kit.ArkTS'

export class Base64HelperMock extends util.Base64Helper {
  decodeSync(src: string | Uint8Array, options?: util.Type | undefined): Uint8Array {
    return new Uint8Array([99,97,10]);
  }
  encodeSync(src: Uint8Array, options?: util.Type | undefined) {
    return new Uint8Array([99,97,10]);
  }
  encodeToStringSync(src: Uint8Array, options?: util.Type | undefined): string {
    return '';
  }
}
// mock-config.json
{
"@ohos.util": {
    "source": "src/mock/Base64Helper.mock.ets"
  }
}

The following error occurs running:

Background Knowledge

Mock capability: In actual development, some interfaces or objects depend on external or complex logic, making them difficult to reproduce in test environments. This makes these interfaces or objects hard to test. In such cases, mock capability can be used.

Troubleshooting Process

Perform the following operations:

Ensure that the export mode of the mock file is the same as that of the mocked interface.
To view the export mode of the mocked interface, press Ctrl and click the mocked interface, as shown in the following figure.

View the export mode of the mock file, as shown in the following figure.

Analysis Conclusion

The export method of the mock file is different from that of the mocked API.

Solution

The export mode of the mock file must be the same as that of the mock (util) API. The export mode of the util API is export default util. Therefore, the export mode of the mock file must be export default mockUtil.

Example code:

1. Create a new ArkTS file under the src/mockBase64HelperMock.mock.ets, and define the mock implementation of the target module in this file.

import { util } from '@kit.ArkTS'
type MockUtil = Record<string, Object>;

export class Base64HelperMock {
  decodeSync(src: string | Uint8Array, options?: util.Type | undefined): Uint8Array {
    console.info('run mock')
    return new Uint8Array([99,97,10]);
  }
  encodeSync(src: Uint8Array, options?: util.Type | undefined) {
    return new Uint8Array([99,97,10]);
  }
  encodeToStringSync(src: Uint8Array, options?: util.Type | undefined): string {
    return '';
  }
}

const mockUtil: MockUtil = {
  'Base64Helper': Base64HelperMock,
}

export default mockUtil

2. Define the mapping relationship between the target module and the mock implementation in the mock configuration file src/mock/mock-config.json5.

{
  "@ohos.util": {
    "source": "src/mock/Base64HelperMock.mock.ets"
  }
}

3. Write the following code in the test file.

import { util } from '@kit.ArkTS'
import { describe, it } from '@ohos/hypium';

export default function localUnitTest() {
  describe('localUnitTest', () => {
    it('assertContain', 0, () => {
      const array = new util.Base64Helper().decodeSync('')
    });
  });
}

Verification Result

Written by Can Kankaya

How does TextInput listen to the delete operation on the keyboard?

HarmonyOS — Fri, 25 Sep 2026 01:58:00 +0000

Read the original article：How does TextInput listen to the delete operation on the keyboard?

How does TextInput listen to the delete operation on the keyboard?

Requirement Description

When TextInput listens to onKeyEvent, no callback is received. How can we listen for the delete operation on the keyboard?

Background Knowledge

onWillDelete: Triggered when a delete operation is about to occur. This callback is not triggered during pre-editing deletion operations. Only supported when using the system input method.
onDidDelete: Triggered when the delete operation is completed. Only supported when using the system input method.

Implementation Steps

Solution 1: Display the input and deletion of TextInput through a Text component to listen for the delete operation of the keyboard.
Solution 2: Use the onWillDelete and onDidDelete callbacks to listen for the delete operation of the keyboard.

Code Snippet / Configuration

Solution 1:

  @Entry
  @Component
  struct TextInputCodeView {
    // Verification code
    @State code: string = '';
    // Number of digits in the verification code
    someArrayLength: number = 4;
    someArray: number[] = [];

    aboutToAppear(): void {
      this.someArray = Array.from({ length: this.someArrayLength });
    }

    build() {
      Column() {
        Stack() {
          Row() {
            ForEach(this.someArray, (item: number, index: number) => {
              // Add spacing
              if (index !== 0) {
                Blank();
                if (item) {
                } // Here, item is only displayed
              }
              // index+1: indicates the position of the input box.
              // Fill in the verification code
              if (this.code.length >= index + 1) {
                this.OneText({
                  str: this.code.substring(index, index + 1),
                  isBorder: index + 1 === this.someArray.length,
                });
              } else {
                // No verification code
                this.OneText({
                  str: '',
                  isBorder: this.code.length + 1 === index + 1
                });
              }
            }, (item: number, index: number) => JSON.stringify(index + 1) + item); // Key identifier
          }
          .width('100%');

          TextInput({ placeholder: '' })
            .width('100%')
            .height('100%')
            .maxLength(this.someArray.length)
            .caretColor(Color.Transparent)
            .fontColor(Color.Transparent)
            .borderColor(Color.Transparent)
            .backgroundColor(Color.Transparent)
            .onChange((value: string) => {
              this.code = value;
            });
        }
        .width('100%')
        .height(60);
      }
      .padding({ right: 12, left: 12, top: 80 });
    }

    // Parameters: verification code content, whether to display a border
    @Builder
    OneText(item: codeOne) {
      // Determine whether the current input box is selected and whether it has content.
      // If it's the selected one and has no content, display '|'
      Text(item.isBorder && !item.str ? '|' : item.str as string)
        .width(50)
        .height(50)
        .textAlign(TextAlign.Center)
        .fontSize(20)
        .fontColor(item.isBorder && !item.str ? '#87ceeb' : Color.Black)
        .backgroundColor('#f3f4f6')
        .borderRadius(8);
    }
  }

  // Verification code input box
  interface codeOne {
    str: string,
    isBorder: boolean
  }

Solution 2:

  @Entry
  @Component
  struct Page {
    @State keyboardVisible: boolean = false;
    @State inputValue: string = '';

    @Builder
    buildCustomKeyboard() {
      Column() {
        Grid() {
          ForEach([1, 2, 3, 4, 5, 6, 7, 8, 9, '*', 0, '#'], (item: number | string) => {
            GridItem() {
              Button(item + '')
                .width(50).onClick(() => {
                this.inputValue += item;
              });
            };
          });
        }.maxCount(3).columnsGap(5).rowsGap(5).padding(3);
      }
      .height('170').width('100%').backgroundColor(Color.Green);
    }

    @Builder
    customKeyboard() {
      this.buildCustomKeyboard();
    }

    build() {
      Column({ space: 10 }) {
        TextInput({ text: this.inputValue })
          .id('Input')
          .customKeyboard(this.keyboardVisible ? this.customKeyboard : undefined)
          .onWillDelete((info: DeleteValue) => {
            let n = 0;
            console.info(`hm-->onWillDelete, n: ${n}, info: ${info}`);
            return true;
          })
          .onDidDelete((info: DeleteValue) => {
            let n = 1;
            console.info(`hm-->onDidDeleten: ${n}, info: ${info}`);
          }).width('80%')

        Button('Toggle Custom Keyboard').onClick(() => {
          this.keyboardVisible = true;
          focusControl.requestFocus('RichEditor');
        });

        Button('Switch to system keyboard').onClick(() => {
          this.keyboardVisible = false;
        });
      }.padding(16)
    }
  }

Test Results

Solution 1:
Solution 2:

Limitations or Considerations

This example supports API Version 20 Release and above.
This example supports HarmonyOS 6.0.0 Release SDK and above.
This example requires DevEco Studio 6.0.0 Release or above for compilation and execution.

Written by Bunyamin Akcay

How to resolve the IPv6 network connection error 'code': 2301101

HarmonyOS — Fri, 25 Sep 2026 01:56:00 +0000

Read the original article：How to resolve the IPv6 network connection error 'code': 2301101

How to resolve the IPv6 network connection error 'code': 2301101

Problem Description

When using mobile data, the initial connection to an IPv6 address is successful. However, after turning off and then turning on the mobile data switch again, attempting to connect to the IPv6 address results in a failure. The tcpSocket.connect throws an exception with the error message: {'code': 2301101, 'essage': 'Network unreachable'}.

Additionally, when subscribing to the network event netAvailable and printing connection information, it was observed that during the initial connection, the linkAddresses included an IPv6 address. After turning off and then turning on the mobile data switch, the printed linkAddresses no longer contained any IPv6 addresses.

The problematic code is as follows:

let conn = connection.createNetConnection();
conn.register((error: BusinessError) => {});
conn.on('netAvailable', ((netHandle: connection.NetHandle) => {
  let properties = connection.getConnectionPropertiesSync(netHandle);
  if (properties && properties.linkAddresses) {
    console.info(LOG_TAG, JSON.stringify(properties.linkAddresses))
  }
  // Connect the socket.
  this.connect()
}));

Log:

03-27 11:10:24.179   A03D00/com.exa...pv6test/JSAPP  apppool               I     ipv6_test [{"address":{"address":"10.74.xxx.6","family":1,"port":0},"prefixLength":32},{"address":{"address":"2409:8915:xxxx:xxxx:8e49","family":2,"port":0},"prefixLength":128}]
03-27 11:10:24.227   A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test socket connect result:true
03-27 11:10:30.012   A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test [{"address":{"address":"10.103.xxx.203","family":1,"port":0},"prefixLength":32}]
03-27 11:10:30.015   A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test tcp connect error:{"code":2301101,"message":"Network unreachable"}
03-27 11:10:30.015   A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test socket connect result:false

Background Knowledge

on('netAvailable'): Subscribes to the network availability event, which is triggered when the network becomes available.
on('netConnectionPropertiesChange'): Subscribes to the network connection information change event, which is triggered when there is a change in network connection information, such as transitioning from no network to having a network, or switching from WiFi to cellular. Actions like turning on the network, turning it off, and then turning it on again also constitute changes in network connection information. Using netConnectionPropertiesChange allows for more intuitive monitoring of network status.

Solution

netAvailable indicates that there is currently an available network, but it does not guarantee that both IPv4 and IPv6 are ready at this time.
When the mobile network is restarted, IPv4 is activated first, followed by IPv6. The netAvailable event is triggered once IPv4 is activated. Therefore, before using IPv6, please ensure that a valid IPv6 address has been assigned; otherwise, the connection will fail.

The code solution is as follows:

conn.on('netConnectionPropertiesChange', ((date: connection.NetConnectionPropertyInfo) => {
  for (let i = 0; i < date.connectionProperties.linkAddresses.length; i++) {
    console.info(LOG_TAG, JSON.stringify(date.connectionProperties.linkAddresses))
    if (date.connectionProperties.linkAddresses[i].address.family === 2) {
      this.connect()
    }
  }
}))

Verification Result

03-28 11:04:25.184   6790-6790     A03D00/com.exa...pv6test/JSAPP  apppool               I     ipv6_test [{"address":{"address":"10.xxx.29.79","family":1,"port":0},"prefixLength":32},{"address":{"address":"2409:891f:xxxx:f5c0","family":2,"port":0},"prefixLength":128}]
03-28 11:04:25.184   6790-6790     A03D00/com.exa...pv6test/JSAPP  apppool               I     ipv6_test [{"address":{"address":"10.xxx.29.79","family":1,"port":0},"prefixLength":32},{"address":{"address":"2409:891f:xxxx:f5c0","family":2,"port":0},"prefixLength":128}]
03-28 11:04:25.222   6790-6790     A03D00/com.exa...pv6test/JSAPP  apppool               I     ipv6_test socket connect result:true
03-28 11:04:45.614   6790-6790     A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test [{"address":{"address":"10.88.xx.24","family":1,"port":0},"prefixLength":32}]
03-28 11:04:45.684   6790-6790     A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test [{"address":{"address":"10.88.xx.24","family":1,"port":0},"prefixLength":32},{"address":{"address":"2409:891f:b805:xxxx:2c7a","family":2,"port":0},"prefixLength":128}]
03-28 11:04:45.685   6790-6790     A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test [{"address":{"address":"10.xx.30.24","family":1,"port":0},"prefixLength":32},{"address":{"address":"2409:891f:xxxx:2232:2c7a","family":2,"port":0},"prefixLength":128}]
03-28 11:04:45.719   6790-6790     A03D00/com.exa...pv6test/JSAPP  com.example.ipv6test  I     ipv6_test socket connect result:true

Written by Baris Tuzemen

Obtaining Real-time Audio Volume During Capture in HarmonyOS for Fluctuating Effects

HarmonyOS — Fri, 25 Sep 2026 01:53:00 +0000

Read the original article：Obtaining Real-time Audio Volume During Capture in HarmonyOS for Fluctuating Effects

Obtaining Real-time Audio Volume During Capture in HarmonyOS for Fluctuating Effects

Context

When recording with audio.AudioCapturer, how to get the real-time volume of the audio data? Need to create a fluctuating effect based on the volume.

Description

API 12 now supports capturing changes in recording volume. Use the getMaxAmplitudeForInputDevice event to get the maximum amplitude of the input device's audio stream.

Solution

Refer to: https://developer.huawei.com/consumer/en/doc/harmonyos-references/js-apis-audio#getmaxamplitudeforinputdevice12

Example usage:

private async getMaxAmplitudeVolume() {
  // Initialize audioDeviceDescriptor
  audio.getAudioManager().getRoutingManager().getPreferredInputDeviceForCapturerInfo({
    source: audio.SourceType.SOURCE_TYPE_MIC,
    capturerFlags: 0
  }).then(async (data) => {
    this.audioDeviceDescriptor = data[0]
  }).catch((err) => {
    console.error("get outputDeviceId error" + JSON.stringify(err));
  })
  this.audioVolumeGroupManager = await audio.getAudioManager().getVolumeManager()
    .getVolumeGroupManager(audio.DEFAULT_VOLUME_GROUP_ID)
  this.volumeInterval = setInterval(() => {
    this.audioVolumeGroupManager?.getMaxAmplitudeForInputDevice(this.audioDeviceDescriptor).then((volume) => {
      this.volume = volume
      console.log("get volume:" + this.volume);
    })
  }, 300)
}

However, this may return 0 frequently. Instead, place getMaxAmplitudeForInputDevice inside the read callback:

let readDataCallback = (buffer: ArrayBuffer) => {
  let audioManager = audio.getAudioManager();
  let capturerInfo = { source: audio.SourceType.SOURCE_TYPE_MIC, capturerFlags: 0 };
  let desc = audioManager.getRoutingManager().getPreferredInputDeviceForCapturerInfoSync(capturerInfo);
  let audioVolumeManager = audioManager.getVolumeManager();
  let audioVolumeGroupManager = audioVolumeManager.getVolumeGroupManagerSync(audio.DEFAULT_VOLUME_GROUP_ID);
  audioVolumeGroupManager.getMaxAmplitudeForInputDevice(desc[0]).then((value) => {
    console.info(`mic volatileume amplitude is: ${value}`);
  })
};

For optimization, initialize manager objects once outside the callback and reuse them inside.

Key Takeaways

• Use getMaxAmplitudeForInputDevice (API 12) to get audio input volume.

• Avoid using setInterval, as it may return 0 frequently.

• Place the API call inside the audio read callback for real-time capture.

• To reduce overhead, initialize singleton audio manager objects once outside the callback.

Additional Resources

https://developer.huawei.com/consumer/en/doc/harmonyos-references/js-apis-audio#getmaxamplitudeforinputdevice12

Written by Baris Tuzemen

It takes a long time for the location service to obtain location information

HarmonyOS — Thu, 24 Sep 2026 01:50:00 +0000

Read the original article：It takes a long time for the location service to obtain location information

Question

It takes a long time for the location service to obtain location information when using the @ohos.geoLocation Manager interface. How to solve it?

Short Answer

The delay occurs because the precision-first policy waits for both GNSS and network positioning results. In poor GPS environments (such as indoors), GNSS cannot provide results, so only the network result is returned after the timeout period, causing a long wait.

To improve performance:

Use the speed-first policy if high precision is not required.
If precision is required, keep the precision-first policy but add a loading page to notify users about potential delays.

Applicable Scenarios

Indoor or weak GPS environments
Apps that do not require high-accuracy location
Apps requiring high precision with user feedback/loading UI
Situations where user experience must be improved during long location retrieval

Reference Link

https://developer.huawei.com/consumer/en/doc/harmonyos-references-V13/js-apis-geolocationmanager-V13#locatingpriority12

Written by Emine INAN

Development Setup Design: Structuring Build Variants for Multi-Device HarmonyOS Applications

HarmonyOS — Thu, 24 Sep 2026 01:46:00 +0000

Read the original article：Development Setup Design: Structuring Build Variants for Multi-Device HarmonyOS Applications

Context

HarmonyOS enables developers to build applications that seamlessly adapt across a wide range of devices, from phones to tablets, smart screens, wearables, and more. A key part of this development strategy involves structuring build variants to efficiently manage different device configurations and deployment environments. This approach ensures optimized performance and consistent user experience across the HarmonyOS ecosystem.

Description

Creating build variants for multi-device HarmonyOS applications involves defining configurations that can adapt to different hardware capabilities, resource availability, and user experience requirements. This process typically includes setting up build profiles, defining device-specific resources, and utilizing HarmonyOS tools such as Hvigor for efficient build customization. The goal is to maintain a single codebase that can be compiled into device-specific packages, ensuring optimal resource usage and performance.

Solution

To effectively structure build variants for multi-device HarmonyOS applications, developers should follow these steps:

1. Define Build Profiles: Utilize the build-profile.json5 file to specify different build configurations for various environments, such as debug and release. This file allows developers to set up signing configurations, target SDK versions, and other product-level settings that are crucial for multi-device support

   {
     "app": {
       "signingConfigs": [
           {
               "name": "release",
               "type": "HarmonyOS",
               "material": {
                   "certpath": "/path/to/cert.cer",
                   "storePassword": "password",
                   "keyAlias": "alias",
                   "keyPassword": "password"
               }
           }
       ],
       "products": [
         {
           "name": "default",
           "signingConfig": "default",
           "targetSdkVersion": "5.1.0(18)",
           "compatibleSdkVersion": "5.1.0(18)",
           "runtimeOS": "HarmonyOS",
           "buildOption": {
             "strictMode": {
               "caseSensitiveCheck": true,
               "useNormalizedOHMUrl": true
             }
           }
         }
       ],
       "buildModeSet": [
         {
           "name": "debug",
         },
         {
           "name": "release"
         }
       ]
     },
     "modules": [
       {
         "name": "entry",
         "srcPath": "./entry",
         "targets": [
           {
             "name": "phone",
             "applyToProducts": ["default"]
           },
           {
             "name": "tablet",
             "applyToProducts": ["default"]
           },
           {
             "name": "wearable",
             "applyToProducts": ["default"]
           }
         ]
       }
     ]
   }

2. Configure Device-Specific Resources: In the module.json5 file, define different resource directories for various device types. This ensures that the application can adapt its UI and functionality based on the target device’s characteristics

   // module.json5
   {
     "module": {
       "name": "entry",
       "type": "entry",
       "deviceTypes": ["phone", "tablet", "wearable"],
       "abilities": [
         {
           "name": "MainAbility",
           "srcEntry": "./ets/mainability/MainAbility.ets",
           "description": "$string:MainAbility_desc",
           "icon": "$media:icon",
           "label": "$string:MainAbility_label",
           "exported": true,
           "skills": [
             {
               "entities": ["entity.system.home"],
               "actions": ["action.system.home"]
             }
           ]
         }
       ]
     }
   }

3. Implement Conditional Compilation: Use conditional compilation to include or exclude code based on the target device or environment. This technique helps reduce the application’s size and improve performance by only including necessary code

   {
     "apiType": "stageMode",
     "buildOption": {
       "resOptions": {
         "copyCodeResource": {
           "enable": false
         }
       }
     },
     "buildOptionSet": [
       {
         "name": "release",
         "arkOptions": {
           "obfuscation": {
             "ruleOptions": {
               "enable": false,
               "files": [
                 "./obfuscation-rules.txt"
               ]
             }
           }
         }
       }
     ],
     "targets": [
       {
         "name": "phone",
         "config": {
           "buildOption": {
             "arkOptions": {
               "buildProfileFields": {
                 "DEVICE_TYPE": "config_phone"
               }
             }
           }
         }
       },
       {
         "name": "tablet",
         "config": {
           "buildOption": {
             "arkOptions": {
               "buildProfileFields": {
                 "DEVICE_TYPE": "config_tablet"
               }
             }
           }
         }
       },
        {
         "name": "wearable",
         "config": {
           "buildOption": {
             "arkOptions": {
               "buildProfileFields": {
                 "DEVICE_TYPE": "config_wearable"
               }
             }
           }
         }
       }
     ]
   }

Generate module build profile and make module

Generated build profile is under build folder:

4. Usage in ArkTS code: You can check your target build in ArkTS dynamically:

   // You can import BuildProfile after generating BuildProfile
   import BuildProfile from 'entry/BuildProfile';

   @Entry
   @Component
   struct Index {
     build() {
       RelativeContainer() {
         Text(BuildProfile.TARGET_NAME) // it will either phone or wearable accordingly the build you have chosen
           .id('HelloWorld')
           .fontSize($r('app.float.page_text_font_size'))
           .fontWeight(FontWeight.Bold)
           .alignRules({
             center: { anchor: '__container__', align: VerticalAlign.Center },
             middle: { anchor: '__container__', align: HorizontalAlign.Center }
           })
       }
       .height('100%')
       .width('100%')
     }
   }

on Phone:

on Wearable:

5. Test Across Devices: Regularly test the application on different devices to ensure that it performs optimally and provides a consistent user experience. This step is crucial for identifying and addressing any issues that may arise due to device-specific differences

Key Takeaways

Single codebase for multiple device types
Environment-specific configuration through build-profile.json5
Device adaptation via module.json5 resource definitions
Hvigor enables advanced build customization
CI/CD integration streamlines deployment

References

Written by Taskhyn Maksim

Obtaining HAP Package Build Time

HarmonyOS — Thu, 24 Sep 2026 01:37:00 +0000

Read the original article：Obtaining HAP Package Build Time

Context

This document explains how to retrieve the build time of HAP packages through Hvigor builds.

Description

How to obtain the build time of HAP packages via Hvigor builds?

Hvigor allows developers to implement their own plugins, where developers can define custom build logic and share it with others.
Hvigor primarily provides two approaches for plugin development:

Solution

Manually insert the build time into a custom JSON file within the afterNodeEvaluate callback function and save it to the rawfile directory. The file can later be read. The hvigorfile.ts under the HAP module is as follows:

import { hapTasks } from '@ohos/hvigor-ohos-plugin';
import { hvigor, HvigorNode, HvigorPlugin } from '@ohos/hvigor';
import * as fs from 'fs';
import path from 'path';

export function customPlugin(): HvigorPlugin {
  return {
    pluginId: 'customPlugin',
    async apply(node: HvigorNode): Promise<void> {
      // Callback function after node evaluation
      hvigor.afterNodeEvaluate((hvigorNode) => {
        // Ensure the directory exists
        const resourcesDir = path.join(__dirname, 'src/main/resources/rawfile');
        if (!fs.existsSync(resourcesDir)) {
          fs.mkdirSync(resourcesDir, { recursive: true });
        }
        // Write build time to JSON file
        const now = new Date();
        const year = now.getFullYear();
        const month = String(now.getMonth() + 1).padStart(2, '0');
        const date = String(now.getDate()).padStart(2, '0');
        const hours = String(now.getHours()).padStart(2, '0');
        const minutes = String(now.getMinutes()).padStart(2, '0');
        const seconds = String(now.getSeconds()).padStart(2, '0');
        const buildTime = `${year}-${month}-${date} ${hours}:${minutes}:${seconds}`;
        const buildInfo = { 'buildTime': buildTime };
        fs.writeFileSync(
          path.join(resourcesDir, 'build_hap_info.json'),
          JSON.stringify(buildInfo, null, 2)
        );
      })
    }
  };
};

export default {
  system: hapTasks,
  plugins: [customPlugin()]
}

Code Execution Screenshot

Constraints & Limitations

This example supports API Version 19 Release and above.
This example supports HarmonyOS 5.1.1 Release SDK and above.
This example requires DevEco Studio 5.1.1 Release or later for compilation and execution.

Key Takeaways

Build time can be captured using the afterNodeEvaluate callback in Hvigor.
The build time can be stored in a JSON file within the rawfile directory for later retrieval.

Reference Link

Written by Taskhyn Maksim

How to solve the problem that the cloud side cannot decrypt after using the HMACSHA1 algorithm to encrypt ArkTS

HarmonyOS — Wed, 23 Sep 2026 01:35:00 +0000

Read the original article：How to solve the problem that the cloud side cannot decrypt after using the HMACSHA1 algorithm to encrypt ArkTS

How to Solve the Problem of Cloud Side Being Unable to Decrypt After Encryption Using HMACSHA1 Algorithm in ArkTS

Problem Description

The issue arises when encrypting critical application data on the device side using HMACSHA1 in ArkTS and decrypting it on the Java-based cloud side. The encrypted outputs mismatch, causing cloud validation failures. HMAC is a hash-based message authentication algorithm ensuring data integrity.

Background Knowledge

For security requirements, key application information must be encrypted on the device side and decrypted on the cloud side to verify data validity. The device uses the HMACSHA1 algorithm implemented in ArkTS, but the encrypted data differs from the Java-based cloud implementation, causing cloud validation to fail.

HarmonyOS encrypted data: 75,199,73,191,89,193,243,73,224,228,50,209,32,40,108,126,240,52,137,165.

Java cloud encrypted data: 75,-57,73,-65,89,-63,-13,73,-32,-28,58,-47,32,40,108,126,-16,52,-119,-91.

HMAC (Hash-based Message Authentication Code) is a hash-based message authentication code algorithm.

(1) Encryption/decryption tests on the HarmonyOS side succeed, confirming HarmonyOS encryption works correctly.

(2) Comparing encrypted data: Values below 128 match (e.g., 75), but values above 128 differ by exactly 256 (e.g., HarmonyOS 199 vs. Java -57 → 199 - (-57) = 256).

(3) Java uses byte (range: -128 to 127). Values >127 overflow during int-to-byte conversion (e.g., 139 becomes -117).

public String generateResponseCode(byte[] challenge) throws GeneralSecurityException, Base32String.DecodingException {
    String secret = "jEWGH2EWEe-pJdZhWPBVDQ0z-cf_fbUjOZGD0ax0BhZw";
    byte[] keyBytes = secret.getBytes();
    final Mac mac = Mac.getInstance("HMACSHA1");
    mac.init(new SecretKeySpec(keyBytes, ""));
    // The encrypted type is byte[], and since we need a numeric password, a conversion algorithm was used to transform byte[] into int.
    byte[] hash = mac.doFinal(challenge);
}

(4) HarmonyOS uses Uint8Array (range: 0 to 255), preserving values like 139 intact.

let macAlgName = 'SH1A';
let mac = cryptoFramework.createMac(macAlgName);
let arr = stringToUint8Array('<sha_string>');
let KeyBlob: cryptoFramework.DataBlob = { data: arr };
let symKeyGenerator = cryptoFramework.createSymKeyGenerator('HMAC');
const symKey = await symKeyGenerator.convertKey(KeyBlob);
await mac.init(symKey);
await mac.update({ data: stringToUint8Array(message) });
let macOutput = await mac.doFinal();

ArkTS Int8Array (range: -128 to 127) matches Java’s byte behavior. Convert doFinal’s Uint8Array output to Int8Array for cloud compatibility.

Solution

Convert the Uint8Array from doFinal to Int8Array:

const uint8Array = new Uint8Array([75,199,73,191,89,193,243,73,224,228,50,209,32,40,108,126,240,52,137,165]);
const int8Array: Int8Array = new Int8Array(uint8Array); // Convert to signed 8-bit array
typescriptCopy Code
const uint8Array = new Uint8Array([75,199,73,191,89,193,243,73,224,228,50,209,32,40,108,126,240,52,137,165]);
const int8Array: Int8Array = new Int8Array(uint8Array); // Convert to signed 8-bit array

Verification Result

(1) When using methods like Mac.doFinal() (returning Uint8Array), convert results to Int8Array if the cloud uses signed bytes.

(2) For any ArkTS method returning Uint8Array, apply similar conversion if values exceed 127 to prevent overflow discrepancies.

Written by Mücahid Kincir

How to Back Up a Relational Database in a Specified Folder?

HarmonyOS — Wed, 23 Sep 2026 01:28:00 +0000

Read the original article：How to Back Up a Relational Database in a Specified Folder?

Context

How to back up a relational database in a specified folder within a Huawei HarmonyOS application. The relational database here is based on SQLite and implemented via ArkTS for data persistence. The solution involves using rdbStore.backUp() for backup and fs.moveFile to relocate the backup file if needed.

Description

How to back up a relational database in a specified folder?

Relational Database: The ArkTS relational database (based on SQLite) provides data persistence for applications.
Relational Database Backup: Backups can be created using rdbStore.backUp(name) to specify a backup name.
fs.moveFile: Moves a source file to a target directory.
Save Files to Public Directory: Allows saving files to a device’s public directory.

Solution

1. By default, ArkTS stores database files in the database directory. The path can be retrieved via the application context: ${this.getUIContext().getHostContext()?.databaseDir}/rdb. After execution, the DB file is generated at: ${this.getUIContext().getHostContext()?.databaseDir}/rdb/RdbTest.db.

const STORE_CONFIG: relationalStore.StoreConfig = {
  name: "RdbTest.db",
  securityLevel: relationalStore.SecurityLevel.S1
}
let rdbStore = await relationalStore.getRdbStore(context, STORE_CONFIG)

2. Generating a Backup File:

Use rdbStore.backUp(name) to create a backup (stored in the same directory as the source DB).
To move the backup to a custom location, use fileIo.moveFile.
Restore using rdbStore.restore('RdbTest_Back.db.back').

rdbStore.backUp('RdbTest_Back.db.back') 
fileIo.moveFile(`${this.getUIContext().getHostContext()?.databaseDir}/rdb/RdbTest_Back.db`,
    `${this.getUIContext().getHostContext()?.filesDir/RdbTest_Back.db.back`)

Saving to Public Directory: Use picker.DocumentViewPicker to save the backup to a public directory

const documentSaveOptions = new picker.DocumentSaveOptions();
documentSaveOptions.newFileNames = ["RdbTest_back.db"];
documentSaveOptions.fileSuffixChoices = ['.db'];
let uris: Array<string> = [];
// Please obtain the context within the component to ensure that `this.getUIContext().getHostContext()` returns a result of type `UIAbilityContext`.
let context = this.getUIContext().getHostContext() as common.UIAbilityContext;
const documentViewPicker = new picker.DocumentViewPicker(context);
documentViewPicker.save(documentSaveOptions).then((documentSaveResult: Array<string>) => {
    uris = documentSaveResult;
    console.info('documentViewPicker.save to file succeed and uris are:' + uris);
}).catch((err: BusinessError) => {
    console.error(`Invoke documentViewPicker.save failed, code is ${err.code}, message is ${err.message}`);
})

rdbStore.backUp does not allow specifying a custom backup directory. Instead, use:

fileIo.moveFile to relocate the backup within sandbox directories.
picker.DocumentViewPicker to save backups to public directories.

Key Takeaways

ArkTS databases default to a specific directory unless specified otherwise.
Backups via rdbStore.backUp() are stored in the same directory as the source DB.
Use fileIo.moveFile to move backups to custom locations.
picker.DocumentViewPicker enables saving backups to public directories.

Written by Taskhyn Maksim

Understanding Huawei Wear Engine Capability Scopes and What Each Permission Does and Why It Matters

HarmonyOS — Wed, 23 Sep 2026 01:24:00 +0000

Read the original article：Understanding Huawei Wear Engine Capability Scopes and What Each Permission Does and Why It Matters

Understanding Huawei Wear Engine Capability Scopes and What Each Permission Does and Why It Matters

Context

Huawei Wear Engine allows a smartphone app to connect and interact with Huawei wearable devices such as smartwatches. Once integrated, your app can exchange messages with the wearable, send notifications, sync data, and request device information or sensor readings.

Communication works both ways the phone can send data to the watch, and apps running on the watch can send information back to the phone.

To use these features, your app must request permission scopes through Huawei’s developer platform. Each scope unlocks a specific category of functionality, and Huawei only allows access to scopes you’ve been approved for. If your app attempts to use features outside its authorized scopes, those API calls will fail.

Some scopes are available to all developers, while others especially those involving health or biometric data require enterprise approval.

Description

To enable Wear Engine in your project, you must apply for the necessary scopes through AppGallery Connect. Huawei manually reviews these requests.

Individual developers can request only the basic scopes:

Device information access
Messaging and notification capabilities

Enterprise developers may request all scopes, including advanced health and sensor access.

For sensitive permissions like health data or raw sensor control, Huawei requires additional documentation such as:

A data usage explanation
A user consent flow description

After your app is approved, you must still obtain permission from the end user at runtime. For example, the first time your app connects to a wearable, the user must authorize the device access request.

If the app attempts to use a scope it wasn't approved for, you’ll see errors like:

Scope unauthorized

Also, ensure that the phone has an active internet connection Wear Engine validates permission scopes through the Huawei Health service.

With setup out of the way, let's look at each capability scope and what it allows.

Solution/ Approach

1. Device Information Access

This scope allows your app to retrieve basic information about paired Huawei wearables. You can get a list of available HarmonyOS-powered devices along with details such as device name and model type.

This scope is essential for identifying which device to connect to or manage.

You can’t interact with a wearable if you don't know it exists. Apps typically use this scope to:

Show a list of paired devices
Confirm that a required smartwatch is connected
Verify compatibility before enabling features

This scope does not expose personal data, so it’s available to all developers including individuals.

2. Wearable Device Status Monitoring

This scope allows your app to check and subscribe to device status updates. With it, your app can:

Check whether the watch is connected
Monitor battery percentage and charging state
Detect whether the user is wearing the device
Subscribe to alerts such as low battery warnings

Some devices also expose available storage or companion-app installation state.

Status monitoring helps your app behave intelligently. Examples:

Delay large data transfers until the watch is charging
Notify the user when battery is critically low
Pause activity tracking when the watch is not being worn
Display warnings when the connection is lost

Like device information retrieval, this scope is commonly available to all developers.

3. Communication and Notifications

This is one of the most important scopes in Wear Engine. It enables real-time messaging and file transfer between the phone and the wearable.

With this permission, your app can:

Send structured messages or commands
Transfer files (images, audio, etc.)
Receive messages from watch apps
Push notifications to the wearable

This is how features like remote controls, app-to-app communication, and custom notification experiences are implemented.

Without this permission, the watch and phone operate independently. With it, the two devices can create a unified experience. Example use cases:

Sending turn-by-turn navigation alerts to the watch
Syncing workout data in real time
Triggering reminders or alarms on the smartwatch
Allowing the watch to control media playback on the phone

This capability is available to individual developers, but should be used responsibly to avoid notification spam or excessive background communication.

4. Wearable Sensor Control

This scope gives apps direct access to raw wearable sensor data and the ability to control those sensors remotely. Supported sensors include:

Accelerometer and gyroscope
PPG
ECG

Apps can start and stop measurements and read real-time sensor output.

Developers use this when they need lower-level data or want to implement custom algorithms. Example use cases:

Gesture-based controls
Fall detection research
Custom stress or fatigue prediction models
Real-time biometric analytics

Because this scope exposes sensitive biometric signals, Huawei restricts it to enterprise projects and requires explicit user authorization.

Key Tkeaways

Huawei Wear Engine uses capability scopes to control how apps interact with wearable devices. Understanding these scopes helps you plan your app’s features, request only the permissions you need, and build a safe experience that respects user data.

Basic Scopes (available to everyone): Device info, status monitoring, messaging and notifications.
Advanced Scopes (enterprise-only): Health data access and direct sensor control.

Before using any scope, make sure your app is approved for it, otherwise you’ll run into authorization errors.

Used correctly, Wear Engine enables powerful cross-device interactions, turning your smartwatch and phone into a seamless experience rather than two isolated devices.

References

https://developer.huawei.com/consumer/en/doc/harmonyos-guides/wear-engine-kit-guide

https://developer.huawei.com/consumer/en/doc/harmonyos-guides/we-business_introduction

https://developer.huawei.com/consumer/en/doc/connectivity-guides/applying-wearengine-ios-0000001935664117

https://developer.huawei.com/consumer/en/doc/connectivity-guides/faq-0000001050818031

https://developer.huawei.com/consumer/en/hms/huawei-wearengine/

DEV Community: HarmonyOS

How to Solve the Issue of prevMargin nextMargin Properties Not Taking Effect in Swiper ?

Problem Description

Background Knowledge

Solution

Verification Result

Written by Egemen Ayhan

How to Fix Targeted Push Issues in Listing Review

Problem Description

Background Knowledge

Troubleshooting Process

Solution

If the app actually includes targeted push functionality:

If the app does not include targeted push functionality:

Verification Result

Written by Egemen Ayhan

How to Resolve the Issue of Base64Helper Inheritance Not Working in Mock

Problem Description

Background Knowledge

Troubleshooting Process

Analysis Conclusion

Solution

Verification Result

Related Documents or Links

Written by Can Kankaya

How does TextInput listen to the delete operation on the keyboard?

How does TextInput listen to the delete operation on the keyboard?

Requirement Description

Background Knowledge

Implementation Steps

Code Snippet / Configuration

Test Results

Limitations or Considerations

Written by Bunyamin Akcay

How to resolve the IPv6 network connection error 'code': 2301101

How to resolve the IPv6 network connection error 'code': 2301101

Problem Description

Background Knowledge

Solution

Verification Result

Written by Baris Tuzemen

Obtaining Real-time Audio Volume During Capture in HarmonyOS for Fluctuating Effects

Obtaining Real-time Audio Volume During Capture in HarmonyOS for Fluctuating Effects

Context

Description

Solution

Key Takeaways

Additional Resources

Written by Baris Tuzemen

It takes a long time for the location service to obtain location information

Question

Short Answer

Applicable Scenarios

Reference Link

Written by Emine INAN

Development Setup Design: Structuring Build Variants for Multi-Device HarmonyOS Applications

Context

Description

Solution

Key Takeaways

References

Written by Taskhyn Maksim

Obtaining HAP Package Build Time

Context

Description

Solution

Constraints & Limitations

Key Takeaways

Reference Link

Written by Taskhyn Maksim

How to solve the problem that the cloud side cannot decrypt after using the HMACSHA1 algorithm to encrypt ArkTS

How to Solve the Problem of Cloud Side Being Unable to Decrypt After Encryption Using HMACSHA1 Algorithm in ArkTS

Problem Description

Background Knowledge

Solution

Verification Result

Written by Mücahid Kincir

How to Back Up a Relational Database in a Specified Folder?

Context

Description