smb big sur

First off, jumping back to here: Using the lsof command, it seems like the Quicklook process has some kind of lock on the file. This is the output of the lsof command: Have you tried sampling (with Activity Monitor) the Quicklook process when it's in this state? I'd like to see if it's idled again or if it thinks it's doing something useful. We do need to support Windows clients connected to networks shares since our app is cross-platform. Our team has in fact proved in the past that open(url.path, O_RDWR | O_NONBLOCK | O_EXLOCK) does work over SMB shares and we're reluctant to switch to a totally different locking system. OK. My main warning here is that, in my experience, belief in how well this work is directly proportional to how broad the testing process has been. Given this additional information, do you think there's anything we can do to address the issue? I don't know. The immediate thing I would try here is changing what's your actually doing/returning, both by either using the draw reply o

Keyed archiving is very Objective-C centric. So, when you encode a Swift Array, it’s actually stored as an NSArray. NSArray can only hold objects. The Swift Bool and Int types are not objects. When you put them in a keyed archive, they get stored as NSNumber objects. Normally this isn’t a big deal because the Swift compiler goes out of its way to help you convert the types. However, when working with a secure keyed archive you have to list the element type, and that has to be an Objective-C object type. So, to decode an array of Bool values, you have to tell the keyed archiving to decode an array of NSNumber objects. Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = eskimo + 1 + @ + apple.com

Hi @DTS Engineer (Kevin). Thanks for your detailed reply. I will add a bit more context to explain how our app uses locking and why. I realized from your answer that it may be different that the common use case. The app locks the file with an exclusive lock when the user opens the file to begin editing it. The file will stay locked as long as it is open. The main goal is to signal other instances of our app on other machines that the file is already open if another user tries to open and edit the same file. We do not want users to start working on a file that someone else may have started working on already and that may have unsaved changes. We are not really interested in preventing other apps from modifying the file because that will rarely happen in our usage scenarios. We do need to support Windows clients connected to networks shares since our app is cross-platform. Our team has in fact proved in the past that open(url.path, O_RDWR | O_NONBLOCK | O_EXLOCK) does work over SMB shares and we're rel

vnode_if.h distributed with Kernel.framework does not define struct vnop_monitor_args: % grep -c 'struct vnop_monitor_args' `xcrun --show-sdk-path`/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/sys/vnode_if.h 0 Because it's defined as a symbol that is private to kernel. Even if I downloaded vnode_if.h from the kernel sources, I wouldn't be able to link against com.apple.kpi.private, would I? All other vnop_name_args structures that aren't defined as kernel private are available in vnode_if.h distributed with Kernel.framework: % awk '/^struct vnop_.*_args/{print $2}' `xcrun --show-sdk-path`/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/sys/vnode_if.h | sort vnop_access_args vnop_advlock_args vnop_allocate_args vnop_blktooff_args vnop_blockmap_args vnop_bwrite_args vnop_clonefile_args vnop_close_args vnop_copyfile_args vnop_create_args vnop_exchange_args vnop_fsync_args vnop_getattr_args vnop_getattrlistbulk_args vnop_getnamedstream_args vnop_getxattr_args vnop_inactive_args vnop

Assuming that the message was from the Core Data framework, the reason would be that Core Data was trying to extend the app's background execution time to do a write request by calling beginBackgroundTask(withName:expirationHandler:), and the API returned invalid, which means that the system didn't allow more background execution time for the app. The error doesn't necessarily indicate a write request failure though, because the app may still have a big enough time window for the request and Core Data may handle the write request in the other way. You'd likely see another error, if a write failure indeed happened. For example, if Core Data was trying to write data and the app was suspended because the background execution time ran out, you would likely see a 0xdeadlock crash. Best, —— Ziqiao Chen  Worldwide Developer Relations.

Without seeing the code, it’s hard tell what exactkly is going on. But I would guess that the Map is simpy embedded into your view with the „safearea“ margins still active, so the system will automatically move the map away from dynamic island and other system elements at the screen borders, so the view is not partly hidden. And if you add your own margins to the view you might get such a big unused area… So no navigation bar needs to be involved here.

At this point I’m going to ask a colleague to wade into this discussion. That would be me... First off, a quick clarification here: On iOS we are using a BGAppRefreshTaskRequest with time interval set to 1 minute, but it appears that we get scheduled only every few hours. This isn't very useful as notifications just arrive in batches rather than in a timely manner. BGAppRefreshTask scheduling is HEAVILY driven by the app usage pattern of a particular device, which means it's behavior can have a VERY wide swing. A pretty good way to thing about it is that it's theoretical goal is to have your task immediately before the user opens your app to do whatever they want to do. For a heavily used app, it can run a few time an hour, but every few hours is inline with what I'd expect for an app that the user isn't interacting with all the time. My big warning here is that on dedicated development devices, these heuristics can trick you into thinking it will fire FAR more frequently that it will in reworld use.

Darkpaw, Code is too big to send in 1 text. I have to send 2.import SwiftUI struct ContentView: View { @State var tipa: [Double] = [] @State var costa: [Double] = [] @State private var cost = @State private var paid = @State var tipp = @State var tipc = @State var tipaa = @State var totalcost = @State var totaltips = @State var totalcash = @State var tipcc = @State var numbc = @State var number = 0 @State var msg = Enter cost and how much was paid. Enter numbers and one . decimal point only. Then press enter. @State var emsg = var body: some View { /* NavigationView { VStack { NavigationLink(destination: viewdetail()) { Text(click) .frame(width: 300, height: 150, alignment: .center) .background(Color.gray) .foregroundColor(.black) } } } */ ZStack { VStack { Text(Driver's Food Delivery) .font(.largeTitle) .fontWeight(.bold) Spacer() Text (msg) Spacer() Spacer() HStack { Text(Cost) .font(.largeTitle) .padding(10) Spacer() Text(Paid) .font(.largeTitle) .padding(10) Spacer() Text(Tip) .font(.t

Have you found a solution? If you know a solution, please share it. I also have a problem where when a local permission pop-up appears and the connection to the file server fails, the entire app cannot connect to the local server from any file server such as Webdav, FTP, or SMB. I believe that this problem persists even if you simply reboot the device or reinstall the app.

this is a big deal for me, as someone wrote some private frameworks that are signed with certificates with my team id that I can't revoke, and I didn't write that code, it's malware. Deverloper support just ignores my pleas to revoke the damn things.

Why does the Local Network Alert appear? It's being triggered by the save. It's primarily being presented for a few different reason: Local push connectivity extensions run in the background for extended periods of time, which inherently has some privacy impact. It's expected that many/most of them will rely on bonjour (or other local network discovery protocols), which require local privacy permission. By design, the life time of local network extension means that presenting the dialog at the point it's actually needed could make the dialog very confusing. Note that 2 & 3 are the big issue here. It might be days or weeks before the user joins the target network and the dialog would need to be presented at the point the user first joined the network, which would be completely disconnected from normal device usage. What happens if the user clicks “Don’t Allow”? Based on my testing, everything seems to work fine even if the user denies the permission. How does your extension find it's server? I'm d

I'm not sure I understand. Do you mean that you would write the scan results to disk while the scan is in progress? Otherwise I don't get the entire scan in memory part. Sort of. The assumption I'm making (which may not be true) here is that your ultimate goal here is already going to involve presenting all of the files in some way. In simplified terms, it's the difference between: Single directory of files. Presenting a list of all the files in a directory. In the first case, all your app NEEDS to track is the data about the specific file it's copying, which it will then discard immediately. In the second case, you have to track all the data you're collecting for every files, since the ultimate goal requires your app to hold all of that data at once. There are a few points then fall out of that dynamic: The memory difference between iteration and recursion ONLY applies in the first case. In the second case both approachs end up holding all records, so the only difference between the two approach is the speci