Comprehensive network communication capabilities including HTTP requests, WebSocket connections, and file transfer operations.
Make HTTP requests with comprehensive options and response handling.
/**
* Make an HTTP request
* @param options - Request configuration options
* @returns RequestTask for managing the request
*/
function request(options: RequestOptions): RequestTask;
interface RequestOptions {
url: string;
data?: any;
header?: object;
method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
dataType?: 'json' | 'text' | 'base64';
responseType?: 'text' | 'arraybuffer';
timeout?: number;
success?: (result: RequestResult) => void;
fail?: (error: RequestError) => void;
complete?: () => void;
}
interface RequestResult {
data: any;
statusCode: number;
header: object;
cookies?: string[];
}
interface RequestTask {
abort(): void;
onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
offHeadersReceived(callback?: Function): void;
}Usage Examples:
import uni from "@dcloudio/uni-app-plus";
// GET request
uni.request({
url: 'https://api.example.com/users',
method: 'GET',
success: (res) => {
console.log('Users:', res.data);
},
fail: (err) => {
console.error('Request failed:', err);
}
});
// POST request with data
const task = uni.request({
url: 'https://api.example.com/users',
method: 'POST',
data: {
name: 'John Doe',
email: 'john@example.com'
},
header: {
'Content-Type': 'application/json'
},
success: (res) => {
console.log('User created:', res.data);
}
});
// Abort request if needed
setTimeout(() => {
task.abort();
}, 5000);Upload files to servers with progress tracking.
/**
* Upload file to server
* @param options - Upload configuration options
* @returns UploadTask for managing the upload
*/
function uploadFile(options: UploadFileOptions): UploadTask;
interface UploadFileOptions {
url: string;
filePath: string;
name: string;
header?: object;
formData?: object;
timeout?: number;
success?: (result: UploadFileResult) => void;
fail?: (error: any) => void;
complete?: () => void;
}
interface UploadFileResult {
data: string;
statusCode: number;
}
interface UploadTask {
abort(): void;
onProgressUpdate(callback: (result: UploadProgressResult) => void): void;
offProgressUpdate(callback?: Function): void;
onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
offHeadersReceived(callback?: Function): void;
}Usage Example:
// Upload image file
uni.chooseImage({
count: 1,
success: (res) => {
const uploadTask = uni.uploadFile({
url: 'https://api.example.com/upload',
filePath: res.tempFilePaths[0],
name: 'image',
formData: {
userId: '12345'
},
success: (uploadRes) => {
console.log('Upload successful:', uploadRes.data);
}
});
uploadTask.onProgressUpdate((progress) => {
console.log('Upload progress:', progress.progress + '%');
});
}
});Download files from servers with progress tracking.
/**
* Download file from server
* @param options - Download configuration options
* @returns DownloadTask for managing the download
*/
function downloadFile(options: DownloadFileOptions): DownloadTask;
interface DownloadFileOptions {
url: string;
header?: object;
filePath?: string;
timeout?: number;
success?: (result: DownloadFileResult) => void;
fail?: (error: any) => void;
complete?: () => void;
}
interface DownloadFileResult {
tempFilePath: string;
statusCode: number;
}
interface DownloadTask {
abort(): void;
onProgressUpdate(callback: (result: DownloadProgressResult) => void): void;
offProgressUpdate(callback?: Function): void;
onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
offHeadersReceived(callback?: Function): void;
}Establish WebSocket connections for real-time communication.
/**
* Connect to WebSocket server
* @param options - WebSocket connection options
* @returns SocketTask for managing the connection
*/
function connectSocket(options: ConnectSocketOptions): SocketTask;
interface ConnectSocketOptions {
url: string;
header?: object;
protocols?: string[];
timeout?: number;
success?: (result: any) => void;
fail?: (error: any) => void;
complete?: () => void;
}
interface SocketTask {
send(options: SendSocketMessageOptions): void;
close(options?: CloseSocketOptions): void;
onOpen(callback: (result: any) => void): void;
onClose(callback: (result: CloseSocketResult) => void): void;
onError(callback: (result: any) => void): void;
onMessage(callback: (result: SocketMessageResult) => void): void;
}Usage Example:
// Connect to WebSocket
const socketTask = uni.connectSocket({
url: 'wss://echo.websocket.org',
success: () => {
console.log('WebSocket connected');
}
});
// Listen for connection open
socketTask.onOpen(() => {
console.log('WebSocket connection opened');
// Send message
socketTask.send({
data: 'Hello WebSocket'
});
});
// Listen for messages
socketTask.onMessage((res) => {
console.log('Received message:', res.data);
});
// Listen for connection close
socketTask.onClose((res) => {
console.log('WebSocket closed:', res.code, res.reason);
});
// Listen for errors
socketTask.onError((error) => {
console.error('WebSocket error:', error);
});Global WebSocket event handlers for simplified usage.
/**
* Listen for WebSocket connection open
* @param callback - Callback function
*/
function onSocketOpen(callback: (result: any) => void): void;
/**
* Listen for WebSocket errors
* @param callback - Callback function
*/
function onSocketError(callback: (result: any) => void): void;
/**
* Listen for WebSocket messages
* @param callback - Callback function
*/
function onSocketMessage(callback: (result: SocketMessageResult) => void): void;
/**
* Listen for WebSocket connection close
* @param callback - Callback function
*/
function onSocketClose(callback: (result: CloseSocketResult) => void): void;
/**
* Send WebSocket message
* @param options - Message options
*/
function sendSocketMessage(options: SendSocketMessageOptions): void;
/**
* Close WebSocket connection
* @param options - Close options
*/
function closeSocket(options?: CloseSocketOptions): void;interface RequestError {
errMsg: string;
errno?: number;
}
interface HeadersReceivedResult {
header: object;
}interface UploadProgressResult {
progress: number;
totalBytesSent: number;
totalBytesExpectedToSend: number;
}interface DownloadProgressResult {
progress: number;
totalBytesWritten: number;
totalBytesExpectedToWrite: number;
}interface SendSocketMessageOptions {
data: string | ArrayBuffer;
success?: (result: any) => void;
fail?: (error: any) => void;
complete?: () => void;
}
interface CloseSocketOptions {
code?: number;
reason?: string;
success?: (result: any) => void;
fail?: (error: any) => void;
complete?: () => void;
}
interface SocketMessageResult {
data: string | ArrayBuffer;
}
interface CloseSocketResult {
code: number;
reason: string;
}