UyaliBeautySDK integration docs

Integration overview

The docs use real code from the UyaliBeautySDK demo: create and reuse one engine instance, send camera frames, image frames, or textures into the SDK, and update only the current parameter state on that same engine instance.

Runtime model

The SDK should not be initialized again for each parameter entry point. The demo keeps one engine instance for a preview or editing flow, starts frame processing first, and applies all later parameter updates to the same instance.

iOS integration

The iOS demo uses UyaliBeautyEngine to process RGBA CVPixelBuffer camera output directly. The engine instance is held by the page, and parameter updates continue to write into that same instance.

Demo integration code

// BeautyFilterController.swift excerpt
import UIKit
import UyaliBeautySDK

class BeautyFilterController: UIViewController, PFCameraDelegate {
    private var camera: PFCamera!
    private var openGLView: PFOpenGLView!
    private let filter = UyaliBeautyEngine()

    override func viewDidLoad() {
        super.viewDidLoad()
        camera = PFCamera()
        camera.delegate = self
        camera.startCapture()
    }

    func didOutputVideoSampleBuffer(_ sampleBuffer: CMSampleBuffer!) {
        guard let sampleBuffer = sampleBuffer,
              let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        filter.process(pixelBuffer: pixelBuffer)
        openGLView.display(pixelBuffer)
    }
}

License

let result = filter.activateLicense(licenseString)
if result.status != .valid {
    print(result.message)
}

Parameter updates

// FaceBeautyDelegate callback excerpt
func getBeautyDeltaValue(value: Float, type: Int) {
    if type == 100 {
        filter.white_delta = value
    } else if type == 101 {
        filter.skin_delta = value
    } else if type == 102 {
        filter.eyeBright_delta = value
    } else if type == 103 {
        filter.teethBright_delta = value
    } else if type == 104 {
        filter.darkCircle_delta = value
    }
}

Android integration

The Android demo uses a texture pipeline for real-time preview. UyaliBeautyTextureProcessor holds the same UyaliBeautyEngine instance, receives the camera OES texture, and outputs the processed texture.

Demo integration code

// UyaliBeautyView.java excerpt
public class UyaliBeautyView extends GLSurfaceView implements GLSurfaceView.Renderer {
    private final UyaliBeautyTextureProcessor textureProcessor;
    private final UyaliBeautyEngine engine;

    public UyaliBeautyView(Context context, AttributeSet attrs) {
        super(context, attrs);
        textureProcessor = new UyaliBeautyTextureProcessor(context);
        engine = textureProcessor.engine();
        setEGLContextClientVersion(3);
        setRenderer(this);
        setRenderMode(RENDERMODE_WHEN_DIRTY);
    }

    private void drawCameraFrame() {
        UyaliBeautyTextureInput input = UyaliBeautyTextureInput.externalOes(
                oesTextureId,
                transform,
                viewWidth,
                viewHeight,
                sourceWidth,
                sourceHeight,
                mirrorFrontCamera,
                cameraSurfaceTexture.getTimestamp(),
                true);
        UyaliBeautyTextureFrame outputFrame = textureProcessor.process(input);
        if (outputFrame != null && outputFrame.isValid()) {
            drawTexture2dToViewport(outputFrame.textureId(),
                    UyaliBeautyTextureInput.IDENTITY_TRANSFORM,
                    viewWidth,
                    viewHeight,
                    outputFrame.width(),
                    outputFrame.height(),
                    true);
        }
    }
}

CPU / image input

UyaliBeautyEngine beauty = beautyView.engine();

beauty.processRgbaInPlace(rgbaBuffer, width, height);

Bitmap output = beauty.processBitmap(bitmap);

UyaliBeautyFrame frame = beauty.process(image, rotationDegrees);

License

UyaliBeautyEngine engine = currentEngine();
UyaliBeautyLicenseResult result = engine.activateLicense(licenseText);
if (result.getStatus() != UyaliBeautyLicenseStatus.VALID) {
    Log.w("UyaliBeauty", result.getMessage());
}

Parameter updates

// MainActivity.java: SeekBar parameter update excerpt
private void applyFeatureValue(Feature feature, int progress, TextView valueLabel) {
    float actual = feature.signed ? progress - 50f : progress;
    valueLabel.setText(displayValue(progress, feature.signed));
    UyaliBeautyEngine engine = currentEngine();
    if (engine != null) {
        engine.setParameter(feature.parameter, actual);
    }
    updateCameraProcessingMode();
    requestCurrentRender();
}

HarmonyOS integration

The HarmonyOS demo holds UyaliBeautyEngine at page level. The real-time camera pipeline can use processCameraFrame, while PixelMap images or preview frames can use processPixelMapInPlace.

Demo integration code

// CameraBeautyPage.ets excerpt
import { UyaliBeautyEngine } from 'uyali_beauty_sdk';

@Entry
@Component
struct CameraBeautyPage {
  private engine: UyaliBeautyEngine = new UyaliBeautyEngine();

  private async handleCameraFrame(frame: CameraFrame): Promise<void> {
    syncBeautyState(this.engine, this.values, this.makeupTypes, this.frontCamera);

    if (frame.kind === 'yuv420') {
      const framePayload = this.cameraFramePayload(frame);
      const result = this.engine.processCameraFrame(framePayload);
      this.status = result.ok ? 'Beauty processing' : 'Current frame failed';
      return;
    }

    const pixelMap = frame.pixelMap;
    const ok = await this.engine.processPixelMapInPlace(pixelMap);
    this.status = ok ? 'Beauty processing' : 'Current frame failed';
  }
}

License

import { UyaliBeautyLicenseStatus } from 'uyali_beauty_sdk';

const result = this.engine.loadLicenseFromRawfile(context, 'uyali/license.lic');
if (result.status !== UyaliBeautyLicenseStatus.VALID) {
  console.info(result.message);
}

Parameter updates

// BeautyCatalog.ets: page state sync to SDK excerpt
export function syncBeautyState(engine: UyaliBeautyEngine, values: Map<string, number>,
  makeupTypes: Map<string, number>, frontCamera: boolean = false): void {
  engine.setCameraFacing(frontCamera);
  BEAUTY_ITEMS.forEach((item: BeautyItem) => {
    engine.setParameter(item.parameter, values.get(item.parameter) ?? item.defaultValue);
  });
  MAKEUP_GROUPS.forEach((group: MakeupGroup) => {
    engine.setParameter(group.parameter, values.get(group.parameter) ?? 0);
    engine.setMakeupType(group.typeParameter, makeupTypes.get(group.typeParameter) ?? 0);
  });
}

License

The SDK supports local signature verification. After app startup, load the License and check whether the authorization is valid. Without a commercial License, whitening and smoothing are free without time limits; all other features can be tried for 120 seconds after SDK initialization.

Beauty

The table below lists base beauty parameters. They are not SDK initialization steps; they are usually written from sliders, switches, presets, or config.

Face reshape

Face reshape depends on face landmark detection and fits selfie, live, and short-video scenes. Products usually provide natural presets first, then allow users to tune individual parameters.

Body shaping

Body shaping depends on body keypoints and contour detection. It fits standing, half-body, and full-body shots. For multi-person or occluded scenes, lower defaults can avoid excessive distortion.

Makeup parameters

Makeup is controlled by type plus intensity. The type is usually set when users choose makeup or switch presets. Type 0 means no makeup asset; intensity 0 hides the effect even if a type is selected.

Makeup type values

iOS example

beauty.makeup_eyebrow_type = .eyebrow_xinyue
beauty.makeup_eyebrow_delta = 45
beauty.makeup_rouge_type = .rouge_mitaose
beauty.makeup_rouge_delta = 35

Android example

beauty.setMakeupType("makeupEyebrowType", 8);
beauty.setParameter("makeupEyebrow", 45f);
beauty.setMakeupType("makeupRougeType", 8);
beauty.setParameter("makeupRouge", 35f);

HarmonyOS example

beauty.setMakeupType('makeupEyebrowType', 8);
beauty.setParameter('makeupEyebrow', 45);
beauty.setMakeupType('makeupRougeType', 8);
beauty.setParameter('makeupRouge', 35);

I/O and debug

FAQ

Can parameters exceed the documented ranges?

The app UI should keep values within the documented ranges to avoid uncontrolled distortion across platforms or input resolutions.

Why does makeup not appear after selecting a type?

Set both type and intensity, and confirm the License includes the MAKEUP capability. Type 0 or intensity 0 hides the makeup.

Why do some advanced effects stop working after a while without a License?

Without a commercial License, features except whitening and smoothing provide a 120-second trial. Read getLicenseTrialSecondsRemaining or the iOS equivalent to get remaining time.