# DynamicDomain

**Repository Path**: icefox406859116/dynamic-domain

## Basic Information

- **Project Name**: DynamicDomain
- **Description**: DynamicDomain
WebSocket
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-30
- **Last Updated**: 2025-07-07

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Alamofire Request Framework

## Description
This is a request framework using Alamofire, designed to demonstrate how to use Alamofire to make network requests, handle responses, and manage downloads, streaming data, and WebSockets, along with request adaptation and retry logic, as well as server trust evaluation.

## Features
- **Making Requests**: Supports common HTTP methods such as GET and POST.
- **Parameter Encoding**: Supports URL and JSON encoding.
- **Response Handling**: Supports handling of data, string, and JSON responses.
- **Download Management**: Supports file downloads and provides resumable download functionality.
- **Streaming Requests**: Supports streaming data processing.
- **WebSockets**: Supports WebSocket requests and message streams.
- **Request Interception**: Supports request adaptation and retry logic.
- **Server Trust Management**: Supports server trust evaluation, including certificate pinning and revocation checks.
- **Redirect Handling**: Supports redirect policies.
- **Network Reachability**: Supports monitoring of network status changes.

## Usage

### Creating a Session
```swift
let session = Session.default
```

### Making a Request
```swift
let url = "https://httpbin.org/get"
let headers: HTTPHeaders = ["Content-Type": "application/json"]

session.request(url, method: .get, headers: headers).response { response in
    switch response.result {
    case .success(let data):
        print("Request succeeded, data: $data ?? "nil")")
    case .failure(let error):
        print("Request failed, error: $error.localizedDescription)")
    }
}
```

### Downloading a File
```swift
let downloadURL = "https://httpbin.org/image/jpeg"
let destination: DownloadRequest.Destination = { _, _ in
    let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
    let fileURL = documentsURL.appendingPathComponent("image.jpeg")
    return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
}

session.download(downloadURL, method: .get, to: destination).responseURL { response in
    if let url = response.value {
        print("File downloaded successfully, path: $url.path)")
    } else {
        print("File download failed: $response.error?.localizedDescription ?? "Unknown error")")
    }
}
```

### Streaming Data Processing
```swift
let streamURL = "https://httpbin.org/stream/100"

session.streamRequest(streamURL).responseStreamString { response in
    switch response {
    case .value(let string):
        print("Streaming data: $string)")
    case .completion(let completion):
        print("Streaming completed, status: $completion.error?.localizedDescription ?? "success")")
    case .error(let error):
        print("Streaming error: $error.localizedDescription)")
    }
}
```

### WebSocket Connection
```swift
@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
let wsSession = Session.default
let wsURL = "wss://echo.websocket.org"

wsSession.webSocketRequest(to: wsURL).connect()
wsSession.webSocketRequest(to: wsURL).streamMessageEvents { event in
    switch event.kind {
    case .message(let message):
        print("WebSocket received message: $message)")
    case .error(let error):
        print("WebSocket error: $error.localizedDescription)")
    case .completion:
        print("WebSocket transmission completed")
    }
}
```

### Request Retry
```swift
let retryPolicy = RetryPolicy.default
let retrier = ConnectionLostRetryPolicy(retryLimit: 3)

let interceptor = Interceptor(adapter: nil, retrier: retrier)

let request = session.request("https://httpbin.org/get", interceptor: interceptor)
request.response { response in
    if let error = response.error {
        print("Request failed, error: $error.localizedDescription)")
    }
}
```

### Server Trust Evaluation
```swift
let serverTrustManager = ServerTrustManager(evaluators: ["example.com": PinnedCertificatesTrustEvaluator()])
let sessionWithTrust = Session.default
sessionWithTrust.serverTrustManager = serverTrustManager
```

### Network Reachability Monitoring
```swift
let reachability = NetworkReachabilityManager()!
reachability.startListening()
reachability.listener = { status in
    switch status {
    case .notReachable:
        print("Network not reachable")
    case .reachable(.ethernetOrWiFi):
        print("Connected via WiFi or Ethernet")
    case .reachable(.cellular):
        print("Connected via cellular network")
    @unknown default:
        break
    }
}
```

## Installation
Ensure you have Swift installed and that your project supports Swift Package Manager or CocoaPods. To install Alamofire using CocoaPods:
```ruby
pod 'Alamofire'
```

## Contribution
Pull Requests are welcome, but please ensure your code complies with the project's coding standards and has been tested before submitting.

## License
This project uses the MIT License. See the [LICENSE](LICENSE) file for details.

## Author
This project is maintained by contributors to Alamofire.