ahmed's questions

我正在尝试将URLSessionSwift 中的一个简单请求转换为使用NWConnection。这是因为我想使用需要身份验证的代理发出请求。我发布了这个关于使用 代理的SO 问题URLSession。不幸的是，没有人回答，但我找到了一个解决方法，NWConnection即使用 。

我的代理 100% 可用，但我的设置有些问题，服务器没有响应。如果能帮我将这个基本的 GET 请求转换为使用 的请求，我将不胜感激NWConnection。我提供的代理可用，请随意使用它进行测试。这个特定的 URL 应该返回 18.5 KB 的数据，即大约 18,000 字节。

如果有人能帮忙就太好了，因为 Swift 需要一个基本的包装器，使用可能需要或不需要 Auth 的代理来简化请求。我将制作一个 OS 包装器NWConnection来简化它的用法。

工作要求

func updateOrderStatus(completion: @escaping (Bool) -> Void) {
    let orderLink = "https://shop.ccs.com/51913883831/orders/f3ef2745f2b06c6b410e2aa8a6135847"

    guard let url = URL(string: orderLink) else {
        completion(true)
        return
    }

    let cookieStorage = HTTPCookieStorage.shared
    let config = URLSessionConfiguration.default
    config.httpCookieStorage = cookieStorage
    config.httpCookieAcceptPolicy = .always
    let session = URLSession(configuration: config)
    var request = URLRequest(url: url)
    request.httpMethod = "GET"

    request.setValue("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", forHTTPHeaderField: "Accept")
    request.setValue("none", forHTTPHeaderField: "Sec-Fetch-Site")
    request.setValue("navigate", forHTTPHeaderField: "Sec-Fetch-Mode")
    request.setValue("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15", forHTTPHeaderField: "User-Agent")
    request.setValue("en-US,en;q=0.9", forHTTPHeaderField: "Accept-Language")
    request.setValue("gzip, deflate, br", forHTTPHeaderField: "Accept-Encoding")
    request.setValue("document", forHTTPHeaderField: "Sec-Fetch-Dest")
    request.setValue("u=0, i", forHTTPHeaderField: "Priority")
    
    let task = session.dataTask(with: request) { data, response, error in
        if let error = error {
            print("Request error: \(error.localizedDescription)")
            completion(false)
            return
        }

        guard let data = data else {
            completion(false)
            print("No data received")
            return
        }

        if let body = String(data: data, encoding: .utf8) {
            completion(true)
        } else {
            completion(false)
            print("Unable to decode response body")
        }
    }

    task.resume()
}

尝试皈依

func updateOrderStatusProxy(completion: @escaping (Bool) -> Void) {
    let orderLink = "https://shop.ccs.com/51913883831/orders/f3ef2745f2b06c6b410e2aa8a6135847"

    guard let url = URL(string: orderLink) else {
        completion(true)
        return
    }
    
    let proxy = "resi.wealthproxies.com:8000:akzaidan:x0if46jo-country-US-session-7cz6bpzy-duration-60"
    let proxyDetails = proxy.split(separator: ":").map(String.init)
    guard proxyDetails.count == 4, let port = UInt16(proxyDetails[1]) else {
        print("Invalid proxy format")
        completion(false)
        return
    }

    let proxyEndpoint = NWEndpoint.hostPort(host: .init(proxyDetails[0]),
                                            port: NWEndpoint.Port(integerLiteral: port))
    let proxyConfig = ProxyConfiguration(httpCONNECTProxy: proxyEndpoint, tlsOptions: nil)
    proxyConfig.applyCredential(username: proxyDetails[2], password: proxyDetails[3])

    let parameters = NWParameters.tcp
    let privacyContext = NWParameters.PrivacyContext(description: "ProxyConfig")
    privacyContext.proxyConfigurations = [proxyConfig]
    parameters.setPrivacyContext(privacyContext)

    let host = url.host ?? ""
    let path = url.path.isEmpty ? "/" : url.path
    let query = url.query ?? ""
    let fullPath = query.isEmpty ? path : "\(path)?\(query)"

    let connection = NWConnection(
        to: .hostPort(
            host: .init(host),
            port: .init(integerLiteral: UInt16(url.port ?? 80))
        ),
        using: parameters
    )

    connection.stateUpdateHandler = { state in
        switch state {
        case .ready:
            print("Connected to proxy: \(proxyDetails[0])")

            let httpRequest = """
            GET \(fullPath) HTTP/1.1\r
            Host: \(host)\r
            Connection: close\r
            Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r
            User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15\r
            Accept-Language: en-US,en;q=0.9\r
            Accept-Encoding: gzip, deflate, br\r
            Sec-Fetch-Dest: document\r
            Sec-Fetch-Mode: navigate\r
            Sec-Fetch-Site: none\r
            Priority: u=0, i\r
            \r
            """

            connection.send(content: httpRequest.data(using: .utf8), completion: .contentProcessed({ error in
                if let error = error {
                    print("Failed to send request: \(error)")
                    completion(false)
                    return
                }

                // Read data until the connection is complete
                self.readAllData(connection: connection) { finalData, readError in
                    if let readError = readError {
                        print("Failed to receive response: \(readError)")
                        completion(false)
                        return
                    }

                    guard let data = finalData else {
                        print("No data received or unable to read data.")
                        completion(false)
                        return
                    }

                    if let body = String(data: data, encoding: .utf8) {
                        print("Received \(data.count) bytes")
                        print("\n\nBody is \(body)")
                        completion(true)
                    } else {
                        print("Unable to decode response body.")
                        completion(false)
                    }
                }
            }))

        case .failed(let error):
            print("Connection failed for proxy \(proxyDetails[0]): \(error)")
            completion(false)

        case .cancelled:
            print("Connection cancelled for proxy \(proxyDetails[0])")
            completion(false)

        case .waiting(let error):
            print("Connection waiting for proxy \(proxyDetails[0]): \(error)")
            completion(false)

        default:
            break
        }
    }

    connection.start(queue: .global())
}
private func readAllData(connection: NWConnection,
                         accumulatedData: Data = Data(),
                         completion: @escaping (Data?, Error?) -> Void) {
    
    connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, context, isComplete, error in
        
        if let error = error {
            completion(nil, error)
            return
        }
        
        // Append newly received data to what's been accumulated so far
        let newAccumulatedData = accumulatedData + (data ?? Data())

        if isComplete {
            // If isComplete is true, the server closed the connection or ended the stream
            completion(newAccumulatedData, nil)
        } else {
            // Still more data to read, so keep calling receive
            self.readAllData(connection: connection,
                             accumulatedData: newAccumulatedData,
                             completion: completion)
        }
    }
}

正确的请求字符串

let httpRequest = "GET \("/51913883831/orders/f3ef2745f2b06c6b410e2aa8a6135847") HTTP/1.1\r\nHost: \("shop.ccs.com")\r\nConnection: close\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15\r\nAccept-Language: en-US,en;q=0.9\r\nAccept-Encoding: gzip, deflate, br\r\nSec-Fetch-Dest: document\r\nSec-Fetch-Mode: navigate\r\nSec-Fetch-Site: none\r\nPriority: u=0, i\r\n\r\n"

我有一个 iOS 消息应用程序 (Swift)，其中一个聊天由 x 个用户组成。单个用户可以参与多个聊天，集合groupChats包含应用程序用户之间的所有群聊。这allUsersUID是一个数组，其中包含该聊天中所有用户的 Firebase UID。该texts集合包含特定聊天的所有消息。用户发送消息时会在该集合中创建一个新文档，并监听同一集合中来自其他用户的新消息。

如果用户 X 向集合发送了一条新消息texts，那么如何向用户 A、B、C 发送推送（横幅、推送、警报）通知，用户 X 能否以编程方式将此通知发送给所有其他用户？我读过这个SO 帖子，但答案是 2018 年的，似乎已经过时了。

在 Go 中我无法弄清楚如何获得以下设置。

• 第一级 goroutine 应该在终止之前停止其第二级 goroutine。
• 如果函数runGoroutine没有循环（我不希望它循环），那么当消息发送到通道时，goroutine 将如何退出？如果没有循环，那么case <-stopChan:只会在开始时被调用一次。
• 如果函数runGoroutine调用其他异步函数会怎么样？当返回时这些函数也会退出吗？

也许我的方法不对。在我的情况下，我有x用户可以启动的任务组，当用户启动任务组时，会创建一个 goroutine（第 1 级）以返回 CL 用户访问权限。此任务组（第 1 级）是yAPI 请求的集合（实际上 y 是 200-300）。对于每个 API 请求，我都会创建一个新的 go-routine（第 2 级）。我的目标是速度；如果我每秒执行数百个 API 请求，将每个请求放入其自己的 goroutine 中是否更快/更有效？或者在 1 个线程上执行是否相同？

                       Parent/Main process
                        |              |
          Child goroutine            Child goroutine
                |                           |
      X bottom goroutines          X bottom goroutines           (API level)
 

package main

import (
    "fmt"
    "time"
)

func runGoroutine(stopChan <-chan struct{}) {
    for {
        select {
        case <-stopChan:
            return // Exit the goroutine
        default:
            fmt.Println("Goroutine is working...")
            time.Sleep(1 * time.Second)
        }
    }
}
func main() {
    stopChan := make(chan struct{})
    // Start the goroutine
    go runGoroutine(stopChan)
    // User should be able to close the routines they want
    close(stopChan)
}

新代码

package main

import (
    "context"
    "log"
    "net/http"
    "sync"
    "time"
)

func main() {
    // Initialize context with cancellation
    ctx, cancel := context.WithCancel(context.Background())

    // Call the worker pool in a separate goroutine to allow main to return immediately

    // We can start any task group like this

    go startWorkerPool(ctx, 20, 100)
    
    // User has CL access on main thread
    // Main function returns, but `cancel` is accessible to allow later cancellation if needed
    log.Println("Worker pool started; you can cancel it by calling cancel()")
    waitForNine()
}

func waitForNine() {
    var input int
    for input != 9 {
        fmt.Print("Enter a number: ")
        fmt.Scan(&input)
    }
}

// startWorkerPool starts a fixed-size worker pool to handle `numRequests` requests.
func startWorkerPool(ctx context.Context, numWorkers, numRequests int) {
    var wg sync.WaitGroup
    work := make(chan string)

    // Launch the specified number of workers
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func(ctx context.Context) {
            defer wg.Done()
            client := http.Client{}
            for url := range work {
                if req, err := http.NewRequestWithContext(ctx, "GET", url, nil); err != nil {
                    log.Println("failed to create new request:", err)
                } else if resp, err := client.Do(req); err != nil {
                    log.Println("failed to make request:", err)
                } else {
                    resp.Body.Close()
                }
            }
        }(ctx)
    }

    // Enqueue URLs for workers and close the channel when done
    go func() {
        for i := 0; i < numRequests; i++ {
            work <- "https://httpbin.org/get"
        }
        close(work)
    }()

    // Wait for all workers to finish
    wg.Wait()
    log.Println("All requests processed")
}

我有一个视图，其中每个列表项都有前/后滑动操作。当我向视图添加拖动手势识别器时，滑动操作变得很难触发。我想向视图添加拖动手势，以允许自定义边缘（左或右）滑动导航到其他视图。我只需要这个拖动手势来识别屏幕的左边缘和右边缘（灰色代表这一点）。如何在有边缘滑动手势的情况下正常触发滑动操作？

import SwiftUI

struct swipeTest: View {
    @State var offset = 0.0
    var body: some View {
        VStack {
            List {
                ForEach(0..<60, id: \.self) { _ in
                    RoundedRectangle(cornerRadius: 10)
                        .frame(height: 50).foregroundStyle(.blue).padding(15)
                        .swipeActions(edge: .trailing) {
                            Button(action: {
                                
                            }, label: {
                                Image(systemName: "bell")
                            }).tint(.orange)
                        }
                        .swipeActions(edge: .leading) {
                            Button(action: {
                              
                            }, label: {
                                Image(systemName: "pin")
                            }).tint(.green)
                        }
                }
            }.listStyle(.plain)
        }
        .offset(x: offset)
        .overlay(alignment: .leading, content: {
            // Only need swipe on very left edge
            Color.gray.opacity(0.3).frame(width: 15)
        })
        .overlay(alignment: .trailing, content: {
            // Only need swipe on very right edge
            Color.gray.opacity(0.3).frame(width: 15)
        })
        .simultaneousGesture (
            DragGesture()
                .onChanged({ value in
                    let width = widthScreen()
                    
                    if value.startLocation.x < 15.0 || value.startLocation.x > (width - 15.0) {
                        offset = value.translation.width
                    }
                })
                .onEnded({ value in
                    offset = 0.0
                })
        )
    }
}

func widthScreen() -> CGFloat {
    let scenes = UIApplication.shared.connectedScenes
    let windowScene = scenes.first as? UIWindowScene
    let window = windowScene?.windows.first
    return window?.screen.bounds.width ?? 0
}


#Preview {
    swipeTest()
}

我有一个基本的 SwiftUI 滚动视图，其中包含许多视频。当我取出视频播放器内的红色时，滚动视图非常平滑，我可以尽可能快地向下和向上滑动，而不会出现任何故障。但是，当我添加红色并向下滑动然后向上滑动时，滚动视图会在视频再次渲染时出现故障。我该如何修复这个故障？此外，Instagram 或 Twitter 等应用程序的视频在出现时就已渲染，滚动离开并返回不会导致它们重新渲染。我怎样才能实现这样的行为？这样做可能会修复视频渲染时的故障。

复制可粘贴代码

import SwiftUI
import AVFoundation
import AVKit

struct allVids: Identifiable, Hashable {
    var id: String
    var video: String?
}

struct MainTabViewXX: View {
    @State var someData: [allVids] = [
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0A514500-F1A0-4093-98A2-2847FE46484A.mp4?alt=media&token=69afd165-1ab6-4686-9ad2-2ce485090fe1"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2FE8937043-873E-4178-A90D-C6C03684C700.mp4?alt=media&token=ddc1f616-5427-4722-a96f-ab81739b243e"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2FE8937043-873E-4178-A90D-C6C03684C700.mp4?alt=media&token=ddc1f616-5427-4722-a96f-ab81739b243e"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2FE8937043-873E-4178-A90D-C6C03684C700.mp4?alt=media&token=ddc1f616-5427-4722-a96f-ab81739b243e"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2FE8937043-873E-4178-A90D-C6C03684C700.mp4?alt=media&token=ddc1f616-5427-4722-a96f-ab81739b243e"),
                allVids(id: UUID().uuidString, video: "https://firebasestorage.googleapis.com:443/v0/b/hustle-85b6c.appspot.com/o/stories%2F0FCE66A1-06F7-47CC-A38A-9A95192A2728.mp4?alt=media&token=57921e5a-e5e6-4b54-919b-39be9fbead84")]
    
    var body: some View {
        ScrollView {
           LazyVStack(spacing: 1){
               ForEach(someData) { message in
                    MessageView(urlV: URL(string: message.video ?? "")!, video: message)
               }
           }
        }.ignoresSafeArea()
    }
}

struct MessageView: View {
    @State var urlV: URL
    let video: allVids
    
    var body: some View {
        VStack {
            MessageVideoPlayerX(url: urlV, viewID: video.id)
        }
    }
}

struct MessageVideoPlayerX: View {
    @State var player: AVPlayer? = nil
    let url: URL
    @State var viewID: String
    
    init(url: URL, viewID: String? = nil) {
        self.url = url
        _viewID = State(initialValue: viewID ?? UUID().uuidString)
    }
    
    var body: some View {
        VStack {
            if let vid = player {
                VidPlayer(player: vid).frame(width: 200, height: 350)
            }
            Color.red.frame(width: 200, height: 300)
        }
        .onAppear {
            if player == nil {
                player = AVPlayer(url: url)
            }
            self.player?.isMuted = true
            
            self.player?.play()
        }
        .onDisappear {
            self.player?.pause()
        }
    }
}

struct VidPlayerX : UIViewControllerRepresentable {
    var player : AVPlayer
    
    func makeUIViewController(context: UIViewControllerRepresentableContext<VidPlayerX>) -> AVPlayerViewController {

        let controller = AVPlayerViewController()
        controller.player = player
        controller.showsPlaybackControls = false
        controller.allowsVideoFrameAnalysis = false
        controller.videoGravity = .resizeAspectFill
        return controller
    }
    
    func updateUIViewController(_ uiViewController: AVPlayerViewController, context: UIViewControllerRepresentableContext<VidPlayerX>) { }
}

您好，我下面有一些代码创建了一个自定义导航堆栈，可以通过全屏滑动来导航离开视图。我想使用此自定义导航堆栈支持 iOS 17，但某些更改修饰符仅适用于 iOS 17。我如何修改.onChange(of: isEnabled, initial: true) { oldValue, newValue 其中位于fileprivate 结构内部FullSwipeModifier: ViewModifier {与 iOS16 一起使用并具有相同的功能？我尝试使用 onRecieve 修饰符，但无法使其工作。

此外，当视图被滑开时，哪里是执行功能的最佳位置。我不希望该函数在滑动中间执行，而是在滑动结束时执行，此时视图已从导航堆栈中弹出。我绝对可以使用 onDisappear 但我不想针对我的具体情况。

import SwiftUI

struct ContentView: View {
    @State private var isEnabled: Bool = false
    var body: some View {
        FullSwipeNavigationStack {
             NavigationLink("Leading Swipe View") {
                 Text("hello").enableFullSwipePop(isEnabled)
             }
        }
    }
}

struct FullSwipeNavigationStack<Content: View>: View {
    @ViewBuilder var content: Content
    /// Full Swipe Custom Gesture
    @State private var customGesture: UIPanGestureRecognizer = {
        let gesture = UIPanGestureRecognizer()
        gesture.name = UUID().uuidString
        gesture.isEnabled = false
        return gesture
    }()
    var body: some View {
        NavigationStack {
            content
                .background {
                    AttachGestureView(gesture: $customGesture)
                }
        }
        .environment(\.popGestureID, customGesture.name)
        .onReceive(NotificationCenter.default.publisher(for: .init(customGesture.name ?? "")), perform: { info in
            if let userInfo = info.userInfo, let status = userInfo["status"] as? Bool {
                customGesture.isEnabled = status
            }
        })
    }
}

extension View {
    @ViewBuilder
    func enableFullSwipePop(_ isEnabled: Bool) -> some View {
        self
            .modifier(FullSwipeModifier(isEnabled: isEnabled))
    }
}

/// Custom Environment Key for Passing Gesture ID to it's subviews
fileprivate struct PopNotificationID: EnvironmentKey {
    static var defaultValue: String?
}

fileprivate extension EnvironmentValues {
    var popGestureID: String? {
        get {
            self[PopNotificationID.self]
        }
        
        set {
            self[PopNotificationID.self] = newValue
        }
    }
}

/// Helper View Modifier
fileprivate struct FullSwipeModifier: ViewModifier {
    var isEnabled: Bool
    /// Gesture ID
    @Environment(\.popGestureID) private var gestureID
    func body(content: Content) -> some View {
        content
            .onChange(of: isEnabled, initial: true) { oldValue, newValue in
                guard let gestureID = gestureID else { return }
                NotificationCenter.default.post(name: .init(gestureID), object: nil, userInfo: [
                    "status": newValue
                ])
            }
            .onDisappear(perform: {
                guard let gestureID = gestureID else { return }
                NotificationCenter.default.post(name: .init(gestureID), object: nil, userInfo: [
                    "status": false
                ])
            })
    }
}

/// Helper Files
fileprivate struct AttachGestureView: UIViewRepresentable {
    @Binding var gesture: UIPanGestureRecognizer
    func makeUIView(context: Context) -> UIView {
        return UIView()
    }
    
    func updateUIView(_ uiView: UIView, context: Context) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.02) {
            /// Finding Parent Controller
            if let parentViewController = uiView.parentViewController {
                if let navigationController = parentViewController.navigationController {
                    /// Checking if already the gesture has been added to the controller
                    if let _ = navigationController.view.gestureRecognizers?.first(where: { $0.name == gesture.name }) {
                        print("Already Attached")
                    } else {
                        navigationController.addFullSwipeGesture(gesture)
                        print("Attached")
                    }
                }
            }
        }
    }
}

fileprivate extension UINavigationController {
    /// Adding Custom FullSwipe Gesture
    /// Special thanks for this SO Answer
    /// https://stackoverflow.com/questions/20714595/extend-default-interactivepopgesturerecognizer-beyond-screen-edge
    func addFullSwipeGesture(_ gesture: UIPanGestureRecognizer) {
        guard let gestureSelector = interactivePopGestureRecognizer?.value(forKey: "targets") else { return }
        
        gesture.setValue(gestureSelector, forKey: "targets")
        view.addGestureRecognizer(gesture)
    }
}

fileprivate extension UIView {
    var parentViewController: UIViewController? {
        sequence(first: self) {
            $0.next
        }.first(where: { $0 is UIViewController}) as? UIViewController
    }
}

我有一个基本的 Heroku 应用程序，如果我不在主应用程序文件中包含from src.RtcTokenBuilder2 import RtcTokenBuilder, Role_Publisher, time ，则运行得很好。我想添加一个文件夹 src，其中包含 Agora RTC 令牌生成的代码。要添加代码，我只需从下面的链接中的 Github 下载代码，然后将 src 文件夹复制并粘贴到我的 python 项目中。我需要的 src 文件夹位于“DynamicKey/AgoraDynamicKey/python3/src”。一旦我将 src 文件夹放在同一目录中，我就会使用上面的 import 语句导入令牌生成。

现在我做git add AccessToken.py AccessToken2.py ChatTokenBuilder2.py DynamicKey.py DynamicKey2.py DynamicKey3.py DynamicKey4.py DynamicKey5.py Packer.py RtcTokenBuilder.py RtcTokenBuilder2.py RtmTokenBuilder.py RtmTokenBuilder2.py SignalingToken.py education_token_builder.py fpa_token_builder.py utils.py

我提交添加内容并运行git push heroku master

通过这样做，heroku git 更新不会出现错误，并且它表示该站点已更新。但是，当我尝试查看已生成的示例令牌时，该网站显示错误并表示使用 heroku 日志来跟踪错误。日志的输出很长，但包括from src.RtcTokenBuilder2 import RtcTokenBuilder、Role_Publisher、时间。ModuleNotFoundError：没有名为“src”的模块

当我添加 src 文件夹并尝试使用它时，我做错了什么？我的设置没有任何问题，因为没有上面的导入一切都正常。

https://github.com/AgoraIO/Tools

骗子服务器.py

from flask import Flask, request
from src.RtcTokenBuilder2 import RtcTokenBuilder, Role_Publisher, time

app = Flask(__name__)

@app.route('/process_data', methods=['GET'])
def process_data():
   x = int(request.args.get('x', 0))
   y = request.args.get('y', 'default')
  
   appId = "test"
   appCertificate = "test"
   expirationTimeInSeconds = 3600

   channelName = y
   uid = x  
   token = "random tok"

   current_timestamp = int(time.time())
   expired_ts = current_timestamp + expirationTimeInSeconds

   token = RtcTokenBuilder.build_token_with_uid(appId, appCertificate, channelName, uid, Role_Publisher, token_expire=expired_ts, privilege_expire=expired_ts)
   
   result = f'token is: {token}'
   return f'<h1>{result}</h1>'

过程文件

web: gunicorn hustlerserver:app

要求.txt

Flask==3.0.1
gunicorn==21.2.0
Jinja2==3.1.3

我需要从 Web 端点获取数据。我将在下面添加说明。我错误地传递了 X-ACCESS-KEY，因为当我运行代码时收到密钥无效或 bin 不属于我的帐户的错误。如何正确地将密钥传递给请求然后解码响应？

我们在以下网址托管了一个 JSON 文件：https://api.jsonbin.io/v3/b/646bed328e4aa6225ea22a79。您的工作是编写一个脚本来下载 URL 的内容（提示：X-ACCESS-KEY 是 $2b$10$Ke1iwieFO7/7qsSKU.GYU.oYXZMW1EeHrwd4xx9ylboJik5mstZk6）按每个元素对数据进行排序 'bar' 键过滤掉其中的元素'baz' 不能被 3 整除 连接每个元素 'foo' 值

let url = URL(string: "https://api.jsonbin.io/v3/b/646bed328e4aa6225ea22a79")!
let key = "$2b$10$Ke1iwieFO7/7qsSKU.GYU.oYXZMW1EeHrwd4xx9ylboJik5mstZk6)"
var request = URLRequest(url: url)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("Bearer \(key)", forHTTPHeaderField: "X-Master-Key")

var jsonData: Data?
let task = URLSession.shared.dataTask(with: request) { (data, _, err) in
    if let error = err {
        print("Error: \(error)")
    } else if let data = data {
        jsonData = data
        processData()
    }
}

task.resume()

func processData(){
    if let jsonData = jsonData,
       let jsonObject = try? JSONSerialization.jsonObject(with: jsonData, options: []) as? [String: Any], let records = jsonObject["records"] as? [[String: Any]] {
      
    }
}

我想将图像放置在屏幕中央。我正在使用KingFisher库中的 KFImage来渲染和显示来自网络的图像。这些图像不会立即渲染，因此 onAppear 方法并不总是足以计算图像大小。在 VStack 中使用 2 个垫片也不起作用。并且将对齐设置为居中也不起作用。我下面的方法对于 UIImages 非常有效，但由于 onAppear 执行时可能无法渲染图像，因此有时会失败。如何使图像居中？

                     KFImage(URL(string: image))
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                            .offset(x: (screenWidth() - imageWidth) / 2.0, y: (screenHeight() - imageHeight) / 2.0)
                            .background (
                                GeometryReader { proxy in
                                    Color.clear
                                        .onAppear {
                                            imageHeight = proxy.size.height
                                            imageWidth = proxy.size.width
                                        }
                                        .onChange(of: currentStory) { _ in
                                            imageHeight = proxy.size.height
                                            imageWidth = proxy.size.width
                                        }
                                }
                            )

当我在 swift UI 中使用高优先级手势时，我没有得到触摸位置，我怎样才能获得这样的值？为什么普通点击手势修饰符会为我提供触摸位置的 CG 点，而高优先级手势却不会。

   .highPriorityGesture(
               TapGesture()
                   .onEnded { loc in
                       
                      // loc.x doesnt work

我想使用长按手势并检测用户何时连续按住 1 秒，并且我还想检测用户何时放开屏幕。目前，onChanged 检测手势何时开始，onEnded 在 1 秒后触发。所以我可以使用 onEnded 来检测用户何时连续按住 1 秒。但我怎么知道用户什么时候放手呢？

Color.blue
                .simultaneousGesture(LongPressGesture(minimumDuration: 1.0)
                    .onChanged { _ in
                        UIImpactFeedbackGenerator(style: .light).impactOccurred()
                    }
                    .onEnded { _ in
                        UIImpactFeedbackGenerator(style: .light).impactOccurred()
                    }
                )

你好，我已经使用相同的微光修饰剂有一段时间了。我最近刚刚更新到新的 IOS，闪光修改器不再起作用。我确保我的代码中没有任何内容被贬值。我不确定它是否不再起作用，我认为这是由于 IOS 动画方式的新更新所致。我很欣赏一些见解。谢谢。

import SwiftUI

public struct Shimmer: ViewModifier {
    let animation: Animation
    @State private var phase: CGFloat = 0

    public init(animation: Animation = Self.defaultAnimation) {
        self.animation = animation
    }

    public static let defaultAnimation = Animation.linear(duration: 1.5).repeatForever(autoreverses: false)

    public init(duration: Double = 1.5, bounce: Bool = false, delay: Double = 0) {
        self.animation = .linear(duration: duration)
            .repeatForever(autoreverses: bounce)
            .delay(delay)
    }

    public func body(content: Content) -> some View {
        content
            .modifier(
                AnimatedMask(phase: phase).animation(animation)
            )
            .onAppear { phase = 0.8 }
    }

    struct AnimatedMask: AnimatableModifier {
        var phase: CGFloat = 0

        var animatableData: CGFloat {
            get { phase }
            set { phase = newValue }
        }

        func body(content: Content) -> some View {
            content
                .mask(GradientMask(phase: phase).scaleEffect(4))
        }
    }

    struct GradientMask: View {
        let phase: CGFloat
        let centerColor = Color.black
        let edgeColor = Color.black.opacity(0.3)
        @Environment(\.layoutDirection) private var layoutDirection

        var body: some View {
            let isRightToLeft = layoutDirection == .rightToLeft
            LinearGradient(
                gradient: Gradient(stops: [
                    .init(color: edgeColor, location: phase),
                    .init(color: centerColor, location: phase + 0.1),
                    .init(color: edgeColor, location: phase + 0.2)
                ]),
                startPoint: isRightToLeft ? .bottomTrailing : .topLeading,
                endPoint: isRightToLeft ? .topLeading : .bottomTrailing
            )
        }
    }
}

public extension View {
    @ViewBuilder func shimmering(
        active: Bool = true, duration: Double = 1.5, bounce: Bool = false, delay: Double = 0
    ) -> some View {
        if active {
            self.modifier(Shimmer(duration: duration, bounce: bounce, delay: delay))
        } else {
            self
        }
    }
    
    @ViewBuilder func shimmering(active: Bool = true, animation: Animation = Shimmer.defaultAnimation) -> some View {
        if active {
            self.modifier(Shimmer(animation: animation))
        } else {
            self
        }
    }
}

您好，我正在使用 YouTube Shorts 制作 TikTok 克隆。我在垂直选项卡视图中呈现视频，允许用户滚动视频列表。由于这些视频位于网络上，我使用网络视图来渲染它们。当用户滚动浏览选项卡视图时，将为新视频创建网络视图的新实例。当用户向后滚动时，他们可以在相同的持续时间内看到之前的视频（已渲染）。这意味着当用户从网页上滑开时，网页视图不会被破坏。滚动几分钟后，由于大量 Web 视图实例需要大量资源，设备会明显变热。当用户超出 2 个视频时，如何销毁这些网络视图。

import SwiftUI
import WebKit
import UIKit

struct AllVideoView: View {
    @State private var selected = ""


    @State private var arr = ["-q6-DxWZnlQ", "Bp3iu47RRJQ", "lXJdgDjw1Ks", "It3ecCpuzgc", "7WNJjr8QM1w", "z2t0W8YSzZo", "w8RBGoH_6BM", "DJNAUBoxW5g", "Gv0X34FZ_8M", "EUTsaD1JFZE",
    "yM9iLvOL2v4", "lnqhfn2n-Jo", "qkUpWwUAFPA", "Uz21KTMGwAI", "682rP7VrMUI",
    "4AOcYT6tnsE", "DEz9ngMqVT0", "VOY2MviU5ig", "F8DvoxgP77M", "LGiRWOawMiw",
    "Ub8j6l35VEM", "0xEQbJxR2hw", "SVow553Lluc", "0cPTM7v0vlw", "G12vO9ziK0k"]


    var body: some View {
        ZStack {
            Color.black.edgesIgnoringSafeArea([.bottom, .top])
            TabView(selection: $selected){
                ForEach(arr, id: \.self){ id in
                    SingleVideoView(link: id).tag(id)
                }
                .rotationEffect(.init(degrees: -90))
                .frame(width: widthOrHeight(width: true), height: widthOrHeight(width: false))
            }
            .offset(x: -10.5) 
            .frame(width: widthOrHeight(width: false), height: widthOrHeight(width: true))
            .rotationEffect(.init(degrees: 90))
            .tabViewStyle(PageTabViewStyle(indexDisplayMode: .never))
        }
    }
}

struct SingleVideoView: View {
    let link: String
    @State private var viewIsShowing = false
    @State private var isVideoPlaying = false
    var body: some View {
        ZStack {
            Color.black
            
            SmartReelView(link: link, isPlaying: $isVideoPlaying, viewIsShowing: $viewIsShowing)

            Button("", action: {}).disabled(true)
            
            Color.gray.opacity(0.001)
                .onTapGesture {
                    isVideoPlaying.toggle()
                }
            
        }
        .ignoresSafeArea()
        .onDisappear {
            isVideoPlaying = false
            viewIsShowing = false
        }
        .onAppear {
            viewIsShowing = true
            isVideoPlaying = true
        }
    }
}

struct SmartReelView: UIViewRepresentable {
    let link: String
    @Binding var isPlaying: Bool
    @Binding var viewIsShowing: Bool
    
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    func makeUIView(context: Context) -> WKWebView {
        let webConfiguration = WKWebViewConfiguration()
        webConfiguration.allowsInlineMediaPlayback = true
        let webView = WKWebView(frame: .zero, configuration: webConfiguration)
        webView.navigationDelegate = context.coordinator

        let userContentController = WKUserContentController()
        
        webView.configuration.userContentController = userContentController

        loadInitialContent(in: webView)
        
        return webView
    }

    func updateUIView(_ uiView: WKWebView, context: Context) {
        var jsString = """
                isPlaying = \((isPlaying) ? "true" : "false");
                watchPlayingState();
            """
        uiView.evaluateJavaScript(jsString, completionHandler: nil)
    }
    
    class Coordinator: NSObject, WKNavigationDelegate {
        var parent: SmartReelView

        init(_ parent: SmartReelView) {
            self.parent = parent
        }
        
        func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
            if self.parent.viewIsShowing {
                webView.evaluateJavaScript("clickReady()", completionHandler: nil)
            }
        }
    }
    
    private func loadInitialContent(in webView: WKWebView) {
        let embedHTML = """
        <style>
            body {
                margin: 0;
                background-color: black;
            }
            .iframe-container iframe {
                top: 0;
                left: 0;
                width: 100%;
                height: 100%;
            }
        </style>
        <div class="iframe-container">
            <div id="player"></div>
        </div>
        <script>
            var tag = document.createElement('script');
            tag.src = "https://www.youtube.com/iframe_api";
            var firstScriptTag = document.getElementsByTagName('script')[0];
            firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);

            var player;
            var isPlaying = false;
            function onYouTubeIframeAPIReady() {
                player = new YT.Player('player', {
                    width: '100%',
                    videoId: '\(link)',
                    playerVars: { 'playsinline': 1, 'controls': 0},
                    events: {
                        'onStateChange': function(event) {
                            if (event.data === YT.PlayerState.ENDED) {
                                player.seekTo(0);
                                player.playVideo();
                            }
                        }
                    }
                });
            }
        
            function clickReady() {
                player.playVideo();
            }
            
            function watchPlayingState() {
                if (isPlaying) {
                    player.playVideo();
                } else {
                    player.pauseVideo();
                }
            }
        
        </script>
        """
        
        webView.scrollView.isScrollEnabled = false
        webView.loadHTMLString(embedHTML, baseURL: nil)
    }
}

func widthOrHeight(width: Bool) -> CGFloat {
    let scenes = UIApplication.shared.connectedScenes
    let windowScene = scenes.first as? UIWindowScene
    let window = windowScene?.windows.first
    
    if width {
        return window?.screen.bounds.width ?? 0
    } else {
        return window?.screen.bounds.height ?? 0
    }
}

更新代码

struct SingleVideoView: View {
    let link: String
    @State private var isVideoPlaying = false
    @State private var destroy = false

    @EnvironmentObject var viewModel: VideoModel

    var body: some View {
        ZStack {
            SmartReelView(link: link, isPlaying: $isVideoPlaying, destroy: $destroy)
            
            Color.gray.opacity(0.001)
                .onTapGesture {
                    isVideoPlaying.toggle()
                }
        }
        .onDisappear {
            isVideoPlaying = false
        }
        .onAppear {
            if viewModel.selected == link {
                isVideoPlaying = true
                destroy = false
            }
        }
        .onChange(of: viewModel.selected, perform: { _ in
            if viewModel.selected != link {
                isVideoPlaying = false
                
                if let x = viewModel.VideosToShow.firstIndex(where: { $0.videoID == viewModel.selected }), let j = viewModel.VideosToShow.firstIndex(where: { $0.videoID == link }){
                    if (x - j) > 2 && !destroy {
                        destroy = true
                        print("destroy \(j)")
                    }
                }
            }
        })
    }
}

struct SmartReelView: UIViewRepresentable {
    let link: String
    @Binding var isPlaying: Bool
    @Binding var destroy: Bool
    
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    func makeUIView(context: Context) -> WKWebView {
        let webConfiguration = WKWebViewConfiguration()
        webConfiguration.allowsInlineMediaPlayback = true
        let webView = WKWebView(frame: .zero, configuration: webConfiguration)
        webView.navigationDelegate = context.coordinator

        let userContentController = WKUserContentController()
        
        webView.configuration.userContentController = userContentController

        loadInitialContent(in: webView)
        
        return webView
    }
    
    func createView(context: Context) { //copy of makeUIView but doesnt return a webview
        let webConfiguration = WKWebViewConfiguration()
        webConfiguration.allowsInlineMediaPlayback = true
        let webView = WKWebView(frame: .zero, configuration: webConfiguration)
        webView.navigationDelegate = context.coordinator
        let userContentController = WKUserContentController()
        webView.configuration.userContentController = userContentController
        loadInitialContent(in: webView)
    }

    func updateUIView(_ uiView: WKWebView, context: Context) {
        
        if destroy && uiView.navigationDelegate != nil {
            destroyWebView(uiView)
        } else if uiView.navigationDelegate == nil {
            createView(context: context)
        }
        
        //rest of code
    }
    
    private func destroyWebView(_ webView: WKWebView) {
        print("destroyed")
        webView.navigationDelegate = nil
        webView.stopLoading()
        webView.removeFromSuperview()
    }
    
    class Coordinator: NSObject, WKNavigationDelegate {
        var parent: SmartReelView

        init(_ parent: SmartReelView) {
            self.parent = parent
        }
        
        func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
            //rest of code
        }
    }
    
    private func loadInitialContent(in webView: WKWebView) {
        let embedHTML = """
            //unchanged
        """
        
        webView.scrollView.isScrollEnabled = false
        webView.loadHTMLString(embedHTML, baseURL: nil)
    }
}