usb_manager/idl/ohos.usbManager.taihe

/*
 * Copyright (C) 2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

@!sts_inject_into_module("import { AsyncCallback } from '@ohos.base';")

@!namespace("@ohos.usbManager", "usbManager")
@!sts_inject("""
static { loadLibrary("usb_manager_taihe_native.z") }
""")

function getDevices(): Array<USBDevice>;

function connectDevice(device: USBDevice): USBDevicePipe;

function hasRight(deviceName: String): bool;

@gen_promise("requestRight")
function requestRightSync(deviceName: String): bool;

function removeRight(deviceName: String): bool;

function addDeviceAccessRight(tokenId: String, deviceName: String): bool;

function getFunctionsFromString(funcs: String): i32;

function getStringFromFunctions(funcs: FunctionType): String;

@gen_promise("setDeviceFunctions")
function setDeviceFunctionsSync(funcs: FunctionType): void;

function getDeviceFunctions(): FunctionType;

function getPortList(): Array<USBPort>;

function getPortSupportModes(portId: i32): PortModeType;

@gen_promise("setPortRoleTypes")
function setPortRoleTypesSync(portId: i32, powerRole: PowerRoleType, dataRole: DataRoleType): void;

function addAccessoryRight(tokenId: i32, accessory: USBAccessory): void;

function claimInterface(pipe: USBDevicePipe, iface: USBInterface, force: Optional<bool>): i32;

function releaseInterface(pipe: USBDevicePipe, iface: USBInterface): i32;

function setConfiguration(pipe: USBDevicePipe, config: USBConfiguration): i32;

function setInterface(pipe: USBDevicePipe, iface: USBInterface): i32;

function getRawDescriptor(pipe: USBDevicePipe): @typedarray Array<u8>;

function getFileDescriptor(pipe: USBDevicePipe): i32;

@gen_promise("usbControlTransfer")
function usbControlTransferSync(pipe: USBDevicePipe, requestparam: USBDeviceRequestParams, timeout: Optional<i32>): i32;

@gen_promise("bulkTransfer")
function bulkTransferSync(
  pipe: USBDevicePipe,
  endpoint: USBEndpoint,
  buffer: @sts_type("Uint8Array") Opaque,
  timeout: Optional<i32>
): i32;

function closePipe(pipe: USBDevicePipe): i32;

function hasAccessoryRight(accessory: USBAccessory): bool;

@gen_promise("requestAccessoryRight")
function requestAccessoryRightSync(accessory: USBAccessory): bool;

function cancelAccessoryRight(accessory: USBAccessory): void;

function getAccessoryList(): Array<USBAccessory>;

function openAccessory(accessory: USBAccessory): USBAccessoryHandle;

function closeAccessory(accessoryHandle: USBAccessoryHandle): void;

struct USBEndpoint {
  address: i32;

  attributes: i32;

  interval: i32;

  maxPacketSize: i32;

  direction: USBRequestDirection;

  endpointAddr: i32;

  type: i32;

  interfaceId: i32;
}

struct USBInterface {
  id: i32;

  protocol: i32;

  clazz: i32;

  subClass: i32;

  alternateSetting: i32;

  name: String;

  endpoints: Array<USBEndpoint>;
}

struct USBConfiguration {
  id: i32;

  attributes: i32;

  maxPower: i32;

  name: String;

  isRemoteWakeup: bool;

  isSelfPowered: bool;

  interfaces: Array<USBInterface>;
}

struct USBDevice {
  busNum: i32;

  devAddress: i32;

  serial: String;

  name: String;

  manufacturerName: String;

  productName: String;

  version: String;

  vendorId: i32;

  productId: i32;

  clazz: i32;

  subClass: i32;

  protocol: i32;

  configs: Array<USBConfiguration>;
}

struct USBDevicePipe {
  busNum: i32;

  devAddress: i32;
}

enum PowerRoleType : i32 {
  NONE = 0,

  SOURCE = 1,

  SINK = 2
}

enum DataRoleType : i32 {
  NONE = 0,

  HOST = 1,

  DEVICE = 2
}

enum PortModeType : i32 {
  NONE = 0,

  UFP = 1,

  DFP = 2,

  DRP = 3,

  NUM_MODES = 4
}

struct USBPortStatus {
  currentMode: i32;

  currentPowerRole: i32;

  currentDataRole: i32;
}

struct USBPort {
  id: i32;

  supportedModes: PortModeType;

  status: USBPortStatus;
}

struct USBControlParams {
  request: i32;

  target: USBRequestTargetType;

  reqType: USBControlRequestType;

  value: i32;

  index: i32;

  data: @typedarray Array<u8>;
}

struct USBDeviceRequestParams {
  bmRequestType: i32;

  bRequest: i32;

  wValue: i32;

  wIndex: i32;

  wLength: i32;

  data: @sts_type("Uint8Array") Opaque;
}

enum USBRequestTargetType : i32 {
  USB_REQUEST_TARGET_DEVICE = 0,

  USB_REQUEST_TARGET_INTERFACE = 1,

  USB_REQUEST_TARGET_ENDPOINT = 2,

  USB_REQUEST_TARGET_OTHER = 3
}

enum USBControlRequestType : i32 {
  USB_REQUEST_TYPE_STANDARD = 0,

  USB_REQUEST_TYPE_CLASS = 1,

  USB_REQUEST_TYPE_VENDOR = 2
}

enum USBRequestDirection : i32 {
  USB_REQUEST_DIR_TO_DEVICE = 0,

  USB_REQUEST_DIR_FROM_DEVICE = 0x80
}

enum FunctionType : i32 {
  NONE = 0,

  ACM = 1,

  ECM = 2,

  HDC = 4,

  MTP = 8,

  PTP = 16,

  RNDIS = 32,

  MIDI = 64,

  AUDIO_SOURCE = 128,

  NCM = 256
}

struct USBAccessory {
  manufacturer: String;

  product: String;

  description: String;

  version: String;

  serialNumber: String;
}

struct USBAccessoryHandle {
  accessoryFd: i32;
}

enum UsbTransferFlags : i32 {
  USB_TRANSFER_SHORT_NOT_OK = 0,

  USB_TRANSFER_FREE_BUFFER = 1,

  USB_TRANSFER_FREE_TRANSFER = 2,

  USB_TRANSFER_ADD_ZERO_PACKET = 3
}

enum UsbTransferStatus : i32 {
  TRANSFER_COMPLETED = 0,

  TRANSFER_ERROR = 1,

  TRANSFER_TIMED_OUT = 2,

  TRANSFER_CANCELED = 3,

  TRANSFER_STALL = 4,

  TRANSFER_NO_DEVICE = 5,

  TRANSFER_OVERFLOW = 6
}

enum UsbEndpointTransferType : i32 {
  TRANSFER_TYPE_ISOCHRONOUS = 0x1,

  TRANSFER_TYPE_BULK = 0x2,

  TRANSFER_TYPE_INTERRUPT = 0x3
}

struct UsbIsoPacketDescriptor {
  length: i32;

  actualLength: i32;

  status: UsbTransferStatus;
}

struct SubmitTransferCallback {
  actualLength: i32;

  status: UsbTransferStatus;

  isoPacketDescs: Array<UsbIsoPacketDescriptor>;
}

struct UsbDataTransferParams {
  devPipe: USBDevicePipe;

  flags: UsbTransferFlags;

  endpoint: i32;

  type: UsbEndpointTransferType;

  timeout: i32;

  length: i32;

  callback: @sts_type("AsyncCallback<SubmitTransferCallback>") Opaque;

  userData: @typedarray Array<u8>;

  buffer: @sts_type("Uint8Array") Opaque;

  isoPacketCount: i32;
}

function usbSubmitTransfer(transfer: UsbDataTransferParams): void;

function usbCancelTransfer(transfer: UsbDataTransferParams): void;

function resetUsbDevice(pipe: USBDevicePipe): bool;