The main bundle lets you access the resources in the same directory as the currently running executable. For a running app, the main bundle offers access to the app’s bundle directory. For code running in a framework, the main bundle offers access to the framework’s bundle directory. On macOS, a GUI application must be built and run from a bundle, which is a directory structure that appears as a single entity when viewed in the Finder. A bundle for an application typically contains the executable and all the resources it needs. Here is the snapshot of an application bundle structure. Manually delete dylib files from Contents/MacOS for services I don't use (my 2D game doesn't need AR, VR, XR, Terrain, etc) Codesign all the.dylib files in the app bundle; Codesign all the.bundle directories in the app bundle; Codesign the app bundle itself, including the -timestamp, -options runtime, and entitlements flags on codesign. How to make app bundle for macOS with OpenCV? Opencv development package not found' I know how to fix it in Qt Creator but I don't know how to fix it in terminal. Bundles in Apple ecosystem refers to entities represented by a specific directory structure. The most common Bundle you encounter are Application Bundles. If you right-click on any application (For example Chess.app) and select Show content, what you'll find is a directory structure. Back to XPC, applications can have may XPC Service bundles.
- Cached
- Macos App Bundle Arguments Dont Working
- Apple Developer Documentation
- See Full List On Wiki.octave.org
- Bundle (macOS) - Wikipedia
- Qt For MacOS - Deployment | Qt 5.11
We have access to many Inter-Process-Communication(IPC) mechanisms in macOS. One of the newest is XPC1. Before XPC a common way to use IPC, and provide services between processes, was through Sockets or Mach Messages (Using Mach Ports).
Nowadays, we are encouraged by Apple to use XPC in our applications and frameworks that provide services. Also, Apple, in their code, has updated many of its frameworks, daemons and applications to use XPC.
XPC, as you can imagine, is an excellent tool to learn. In this post, we are going to learn:
- How to use XPC in our applications to break it into small modules that provide services that can be requested only when needed. Imagine an app that has code dedicated to a specific task. But the task is seldom used. The application doesn't need to have that code always in memory, increasing the process' memory footprint. We can use XPC Services (Notice capital S) that provide services that will only be executed when needed. Also, the services can be stopped if the OS needs more memory or if the process has been idle for an extended period.
Let's examine what we can accomplish using XPC.
* You can check the full code in the GitHub Repository
*Update: You can check the following post if you are interested in creating a Launch Agent that provides XPC services.
Table of Contents
- Creating a macOS application that includes an XPC Service
XPC provides us with a new abstraction for Inter-Process-Communication, a simple abstraction that on its own it's convenient (using
MIG
is complicated). But aside from having an easier to use IPC mechanism, XPC implementation also gives us some additional benefits. We'll examine the benefits later but first, let's explore some use-cases of XPC.As mentioned before, the XPC mechanism offers an alternative to sockets (or Mach Services using
MIG
) for IPC. We could have, for example, a process that acts as a 'server' waiting for clients to access it's API and provide some service. Download qt designer python mac.Imagine we have an application that handles the user's contacts. The app provides an API that you could access from your applications and query for details on the user's contacts. That example could very easily be an XPC service provided by
AddressBook.app
. We don't access the XPC service directly we use the API provided by Contacts.framework
, but the framework is based on XPC services.XPC services used in this way are an excellent way to communicate different processes. The exchange of data in XPC is through
Plists
, that also allows for data type validation.When we talk about XPC Services (capital 'S'), we are referring to the bundle called XPC Service. Bundles in Apple ecosystem refers to entities represented by a specific directory structure. The most common Bundle you encounter are Application Bundles. Best mac app to make a poster creator. If you right-click on any application (For example
Chess.app
) and select Show content
, what you'll find is a directory structure.Back to XPC, applications can have may XPC Service bundles. You'll find them inside the
Contents/XPCServices/
directory inside the application bundle. You can search in your /Applications
directory and see how many of the applications rely on XPC Services.The XPC Services inside each application provide services that can be easily accessed from the main
Application
. You can also have XPC Services inside Frameworks
(Which are another type of Bundle). You can check the frameworks on your computer for some examples:Using XPC Services in our apps allow us to break some functionality in separate modules (The XPC Service). We could create an XPC Service that can be in charge of running some costly but infrequent tasks. For example, some crypto task to generate random numbers.
Breaking our application into specific services allows us to keep our main application leaner, and also take less memory while running. Only running our XPC Service on demand.
Another additional benefit is that the XPC Service runs on its own process. If that process crashes or it's killed, it doesn't affect our main application. Imagine that your application support user-defined plugins. And the plugins are built using XPC Services. If they are poorly coded and crash, they won't affect the integrity of your main application.
An additional benefit to the XPC Service is that they can have their own entitlements. The application will only require the entitlement when it makes use of a service provided by XPC Service that requires the entitlement. Imagine you have an app that uses location but only for specific features. You could move those features to an XPC Service and add the location entitlement only to that XPC Service. If your user never needs the feature that uses the location, it won't be prompted for permissions, making the use of your app more trustworthy.
Those are some of the benefits of using XPC. Let's see how XPC Services are managed.
We've discussed that the XPC Service can be run on-demand, but who is in charge of managing your XPC Service?
launchd
is the first process to run on our system. It is in charge of launching and managing other processes, services and daemons. launchd
is also in charge of scheduling tasks. So it makes sense that launchd
will also be responsible for the management of XPC Services.As I mentioned before, our XPC Service can be stopped if it has been idle for a long time, or be spawned on demand. All the management is done by
launchd
, and we don't need to do anything for it to work.launchd
has information about system-wide resource availability and memory pressure, who best to make decisions on how to most effectively use our system's resources than launchd
. This is an ingenious implementation if you ask me.Ok, enough theory on XPC let's do something practical.
Let's create an application that makes use of an XPC Service. We are going to be using an Agent-based Menu bar application. Much like the application we created on the post 'Understanding a few concepts of macOS applications by building an agent-based (menu bar) app'.
We'll build the application and XPC Service using the Swift Package Manager. https://bitsenergy937.weebly.com/god-hand-game-download-for-android-phone.html. If you want a refresher on how to create apps without using Xcode, check that post.
Our XPC Service will provide a function that will obtain our public IP. We'll add the new option to our 'menu bar' application(the new option will call our XPC Service).
I'll go a little faster here until we reach the XPC code, all the rest was covered in the other post.
Start by creating the directory and initialising the Swift project. The name doesn't matter. I'll be using the code on the mentioned post as the base so I'll call my project
XPCSquirrel
as the code before was only Squirrel
:As I mentioned, we are going to base our code on the previous
Squirrel
implementation. I'm just going to show you the complete files and not go into detail explaining how they work until we reach the XPC related code.The
main.swift
looks like this:The
AppDelegate.swift
will have this content:We are going to create the Application Bundle and XPC Service bundle by hand. This means that we are going to manually create the
Info.plist
s for each of the bundles. We are going to create them in a directory called SupportFiles
, and then move them to their proper place in the Application and XPC Service bundles.We are creating the bare bones of the bundles, so there is a lot of information missing. The application bundle we'll create, certainly won't get approved by the App Store. But for understanding how everything works is better to only look at what is required.
Create a file
MainInfo.plist
that will host our application bundle's Info.plist
. And add the following content: (LSUIElement
identifies our application as an Agent so that it won't show an icon in the Dock or on the task switcher).Now create the Plist file for our XPC Service. Create a file with the name
XPCInfo.plist
with the following content:Those are the required fields for an XPC Services bundle
Info.plist
file. The CFBundleIndentifier
is used as the service name. Later we'll use that name when locating the service.Your file structure should look something like this:
Ok, now can focus on the code for the XPC Service.
Finally, let's work with XPC.
We are going to add a new target to our
Package.swift
that will represent our XPC Service code.Edit the
Package.swift
and add the new target:Now let's create a new directory inside
Sources
that will contain our XPC code.Create a new file inside
Sources/ServiceProvider
called main.swift
. This will be our entry point for our XPC Service bundle. From our main
will listen for new connections and handle their requests.The workflow is the following:
(1) We create a listener and (2) set its delegate object. The delegate is in charge of accepting and setting up new incoming connections. Once our listener has a delegate, we call
resume
that will indicate to our listener to (3) start 'listening' for connections.This is how our
main.swift
will look:We haven't created
ServiceDelegate
yet, so let's do that. Our delegate should implement the NSXPCListenerDelegate
protocol that requires the implementation of the listener
function that sets up the incoming connections. listener
has the following signature:The boolean that is returned indicates if the connection was accepted. We can do any validations and then decide if we accept the connection or not.
Ok, let's work on our delegate. Create a new file inside
Sources/ServiceProvider
called ServiceDelegate.swift
and add the following content:First, we set up the exported interface to be represented by the
ServiceProviderXPCProtocol
(we'll be creating that protocol next). This protocol defines the interface for our Service. It defines what functions we provide and their signatures. We are now on the 'server' side of the connection, but in the 'client' side will also need to have the protocol that defines our interface.After setting
exportedInterface
, we create an object that implements our protocol. The object will be the one called when our service functions are requested. We set our connection's exportedObject
property to the Object that implements our protocol.When a new connection is created, it begins its execution life in a stopped state. We use
resume
to start it.If everything went ok, we return
true
to indicate that the connection was accepted and configured.As we decided before, our XPC service will provide a service that obtains our public IP and executes the closure we got as a parameter(
withReply
) with our IP.Create the file
ServiceProviderXPCProtocol.swift
and add the following content:Now, let's create a new file where we'll implement the protocol. Create the file
ServiceProviderXPC.swift
inside Sources/ServiceProvider/
. And add the following content:That function uses the
dig
command to obtain our public IP. The bulk of the code is related to running the dig
command, but the code relevant to XPC is only sending our ip
obtained by dig
to the reply
closure.Alright, we have our XPC Service side complete. Let's work on accessing our XPC Service form the main application.
Using our XPC Service
Apple has done an excellent job making the use of XPC Services very straight forward. The workflow is the following:
(1) We create a connection to the service we want to use. The service is looked up by name (The
CFBundleIdentifier
in the XPC Service's Info.plist
remember?). (2) Set the remote object Interface, here we need to know the protocol that describes the interface, the one we used to create the service on the XPC Service bundle. (3) Get an instance of the object that implements the interface (using remoteObjectProxy
). (4) And last, make use of the service. Remember that the calls are always asynchronous that means if we are going to work with the UI, we need to send it through the main
Queue, so we don't block the main thread.Ok, let's see our implementation. We are going to be working on the
AppDelegate.swift
file. Let's add a new option to the statusBarMenu
that allows us to call the method to display our public IP.We need to define our function,
xpcCall
. Let's do that:As you can see, we are defining the
remoteObjectInterface
using ServiceProviderXPProtocol
, but we haven't defined it yet for the main application. You can copy it from the Sources/ServiceProvider/
directory and paste it in Sources/XPCSquirrel
directory.We are using
connection.remoteObjectProxyWithErrorHandler
that allows us to pass a closure to handle any errors and obtain an instance of the object that implements the ServiceProviderXPCProtocol
.Then we call our function
getPublicIp(withReply:)
using the inline closure syntactic sugar to pass the closure. In the closure we set our statusBarItem.button?.title
to be the ip
we get from the service.Very cool right?
Next, you'll see the full
AppDelegate.swift
file. I also included some additional changes. For example, the option to show the counter. This way, we can go back to using our App as a counter after we've checked our public ip
.We now have all the code, but we still need to put everything together. We need to build the application and add the XPCService to the proper place in the main application's bundle. Application bundles can have as many XPC Service bundles as they need, they are located inside the
XPCServices
folder inside Contents
.I'll automate the process using
make
so we don't have to do it all by hand. You can see the Makefile
next:As you can see, we create all the Application Bundle structure and create the XPC bundle. Let's run the
make
command and generate our XPCSquirrel.app
.This generates the
XPCSquirrel.app
bundle that has the following structure:Onenote 2010 free download. Now you can run the application by double-clicking it on
Finder
or using the open
command on the shell:If you can't see the app in your taskbar, switch to
Finder
, it might be covered by some menu items in your current application. Now you can click Get public ip
, and you should see your IP in the taskbar.Congratulations! You just used XPC Services in your application.
There are more uses for XPC as Inter-Process-Communication, other than creating XPC Service bundles in your applications. One of the most useful, in my opinion, is creating a
LaunchAgent
that provides some services that many apps can connect to and obtain information.For example, an application that does grammar and spelling checking (Grammarly maybe?). The app can expose an XPC service that you can send a block of text, and it'll return an object with the corrections.
Notice the lower-case 's' in that use of XPC service, we are not talking about a bundle but a service that can be accessed from other applications.
Ok, that's it for this week. Let me know if you like the post and any other use you give toXPC.
* You can check the full code in the GitHub Repository
- Apple's documentation no Creating XPC Services, also, Daemons and Services Programming Guide
- I didn't find many resources for XPC aside from Apple's API documentation. There was a lot of trial and error to get it to work. Here is the Apple - XPC documentation
- I have no idea what XPC stands for, if you have any clues, please let me know :). ↩
** If you want to check what else I'm currently doing be sure to follow me on twitter @rderik or subscribe to the newsletter. If you want to send me a direct message you can send it to [email protected].
-->There are two basic ways that you, as an administrator, can deploy the OneDrive sync app to Mac users in your organization:
- Have users install and set up the OneDrive sync app themselves by following the instructions in Sync files with OneDrive on Mac OS X. To install the OneDrive sync app for Mac, a user has to be an administrator on the Mac or know an administrator account name and password.
- Download the installer package file to your local network, and then use your software distribution tools to deploy the app to your users. By using a software distribution tool, you have more control over the deployment, including which users get the sync app and when. The OneDrive sync app for Mac uses the Apple Installer technology for installation. This means you can continue to use the software distribution tools that you normally use to deploy software to Mac users. You can use Microsoft Intune. Other common tools are Jamf Pro, Munki, and AutoPkg. You can also use Apple Remote Desktop and AppleScript.
Manage OneDrive settings on macOS using property list (Plist) files
After the OneDrive sync app for Mac is installed, users can configure settings for the app. These settings are called preferences. As an administrator, you might want to provide users in your organization with a standard set of preferences. Preferences for the OneDrive sync app for Mac are stored in preference files. These files are often referred to as .plist files.
Standalone | Mac App Store | |
---|---|---|
PList Location | ~/Library/Preferences/com.microsoft.OneDrive.plist | ~/Library/Containers/com.microsoft.OneDrive-mac/Data/Library/Preferences/com.microsoft.OneDrive-mac.plist |
Domain | com.microsoft.OneDrive | com.microsoft.OneDrive-mac |
Configure sync app settings
Configure the settings on macOS as follows:
- Cricket app for mac. Quit the OneDrive app.
- Define the settings you want to change by creating a Plist file with the values, or use a script to set the default values.
- Deploy the settings onto the local computer.
- Refresh the preferences cache.https://vmqzlr.weebly.com/free-mac-app-deals.html. On the next start of OneDrive, the new settings will be picked up.
Overview of settings
Use the following keys to preconfigure or change settings for your users. The keys are the same whether you run the standalone or Mac App Store edition of the sync app, but the Plist file name and domain name will be different. When you apply the settings, ensure that you target the appropriate domain depending on the edition of the sync app.
Cached
List of settings
AllowTenantList
This setting prevents the users from uploading files to other organizations by specifying a list of allowed tenant IDs. If you enable this setting, the user gets an error if they attempt to add an account from an organization that is not in the allowed tenants list. If the user has already added the account, the files stop syncing. This setting takes priority over Block syncing OneDrive accounts for specific organizations setting. Do NOT enable both settings at the same time.
The parameter for the AllowTenantList key is TenantID and its value is a string which determines the tenants for whom the Allow Tenant setting is applicable. For the setting to be complete, this parameter also requires a boolean value to be set to it. If the boolean value is set to True, the tenant is allowed to sync.
The example for this setting in the .plist file is:
<key>AllowTenantList</key>
<array>
<dict>
<key>TenantId1</key>
<Bool>True</Bool>
<key>TenantId2</key>
<Bool>True</Bool>
</dict>
</array>
<key>AllowTenantList</key>
<array>
<dict>
<key>TenantId1</key>
<Bool>True</Bool>
<key>TenantId2</key>
<Bool>True</Bool>
</dict>
</array>
AutomaticUploadBandwidthPercentage
This setting enables the sync app to automatically set the amount of bandwidth that can be used for uploading files, based on available bandwidth.
To enable this setting, you must define a number between 1 and 99 which determines the percentage of bandwidth the sync app can use out of the total available bandwidth.
The example for this setting in the .plist file is:
<key>AutomaticUploadBandwidthPercentage</key>
<int>(Bandwidth)</int>
<key>AutomaticUploadBandwidthPercentage</key>
<int>(Bandwidth)</int>
BlockExternalSync
This setting prevents the sync app from syncing libraries and folders shared from other organizations.
If you set the setting's value to True, the users are prevented from syncing OneDrive and SharePoint libraries and folders with organizations other than the user's own organization. Set this value to False or do not enable the setting to allow the OneDrive and SharePoint files to be synced with other organizations also.
The example for this setting in the .plist file is:
<key>BlockExternalSync</key>
<(Bool)/>
<key>BlockExternalSync</key>
<(Bool)/>
BlockTenantList
This setting prevents the users from uploading files to organizations that are included in the blocked tenant IDs list that is specified.
If you enable this setting, the users get an error if they attempt to add an account from an organization that is blocked. If a user has already added an account for a blocked organization, the files stop syncing. This setting does NOT work if you have Allow syncing OneDrive accounts for only specific organizations setting enabled. Do NOT enable both settings at the same time.
You must enable this setting by defining IDs for the TenantID parameter which determines the tenants to whom the block tenant setting is applicable. You must also set the boolean value to True for the ID of every tenant you want to prevent from syncing with the OneDrive and SharePoint files and folders.
Note: In the list, inclusion of the tenant ID alone does not suffice. It is mandatory to set the boolean value to True for the ID of each tenant who is to be blocked.
The example for this setting in the .plist file is:
<key>BlockTenantList</key>
<array>
<dict>
<key>TenantId1</key>
<Bool>True</Bool>
<key>TenantId2</key>
<Bool>True</Bool>
</dict>
</array>
<key>BlockTenantList</key>
<array>
<dict>
<key>TenantId1</key>
<Bool>True</Bool>
<key>TenantId2</key>
<Bool>True</Bool>
</dict>
</array>
DefaultFolderLocation
This setting specifies the default location of the OneDrive folder for each organization.
The parameters are TenantID and DefaultFolderPath.The TenantID value is a string that determines the tenants to whom the default folder location setting is applicable.The DefaultFolderPath value is a string that specifies the default location of the folder.
The following are the conditions governing the default folder location:-Mac app store: The path must already exist when the user is setting up the sync app.-Standalone: The path will be created (if it doesn't already exist) after the user sets up the sync app. Only with the Standalone sync app you can prevent users from changing the location.
The example for this setting in the .plist file is:
<key>DefaultFolder</key>
<array>
<dict>
<key>Path</key>
<string>(DefaultFolderPath)</string>
<key>TenantId</key>
<string>(TenantID)</string>
</dict>
</array>
<key>DefaultFolder</key>
<array>
<dict>
<key>Path</key>
<string>(DefaultFolderPath)</string>
<key>TenantId</key>
<string>(TenantID)</string>
</dict>
</array>
DisableHydrationToast
This setting prevents toasts from appearing when applications cause file contents to be downloaded.
If you set the setting's value to True, toasts do not appear when applications trigger the download of file contents.
The example for this setting in the .plist file is:
<key>DisableHydrationToast</key>
<(Bool)/>
Github app on mac.
<key>DisableHydrationToast</key>
<(Bool)/>
Github app on mac.
DisablePersonalSync
This setting blocks users from signing in and syncing files in personal OneDrive accounts. If this setting has been configured after a user has set up sync with a personal account, the user gets signed out.
If you set the setting's value to True, the users are prevented from adding or syncing personal accounts.
The example for this setting in the .plist file is:
<key>DisablePersonalSync</key>
<(Bool)/>
<key>DisablePersonalSync</key>
<(Bool)/>
DisableTutorial
This setting prevents the tutorial from being shown to the users after they set up OneDrive.
If you set this setting's value to True, the tutorial is blocked from being shown to the users after they set up the OneDrive.
The example for this setting in the .plist file is:
<key>DisableTutorial</key>
<(Bool)/>
<key>DisableTutorial</key>
<(Bool)/>
DownloadBandwidthLimited
This setting sets the maximum download throughput rate in kilobytes (KB)/sec for computers running the OneDrive sync app.
You must set this setting's value to an integer between 50 KB/sec and the maximum rate is 100,000 KB/sec which determines the download throughput in KB/sec which the sync app can use.
The example for this setting in the .plist file is:
<key>DownloadBandwidthLimited</key>
<int>(Download Throughput Rate in KB/sec)</int>
<key>DownloadBandwidthLimited</key>
<int>(Download Throughput Rate in KB/sec)</int>
FilesOnDemandEnabled
Macos App Bundle Arguments Dont Working
This setting specifies whether Files On-Demand is enabled.
If you don't set this setting, Files On-Demand will be enabled automatically as we roll out the feature, and users can turn the setting on or off.
If you set this setting to True, FilesOnDemand is enabled and the users who set up the sync app can view the online-only files, by default.
If you set this setting to False, FilesOnDemand is disabled and the users won't be able to turn it on.
The example for this setting in the .plist file is:
<key>FilesOnDemandEnabled</key>
<(Bool)/>
<key>FilesOnDemandEnabled</key>
<(Bool)/>
HideDockIcon
This setting specifies whether a dock icon for OneDrive is shown.
If you set this setting's value to True, the OneDrive dock icon is hidden even if the app is running.
The example for this setting in the .plist file is:
<key>HideDockIcon</key>
<(Bool)/>
<key>HideDockIcon</key>
<(Bool)/>
HydrationDisallowedApps
This setting prevents apps from automatically downloading online-only files. You can use this setting to lock down apps that don't work correctly with your deployment of Files On-Demand.
To enable this setting, you must define a string in JSON format as described below:
'appID' can be either the BSD process name or the bundle display name. 'MaxBuildVersion' denotes the maximum build version of the app that will be blocked. 'MaxBundleVersion' denotes the maximum bundle version of the app that will be blocked.
[{'ApplicationId':'appId','MaxBundleVersion':'1.1','MaxBuildVersion':'1.0'}]
'appID' can be either the BSD process name or the bundle display name. 'MaxBuildVersion' denotes the maximum build version of the app that will be blocked. 'MaxBundleVersion' denotes the maximum bundle version of the app that will be blocked.
Apple Developer Documentation
The example for this setting in the .plist file is:
<key>HydrationDisallowedApps </key>
<string>
<(Bool)/>
<key>HydrationDisallowedApps </key>
<string>
[{'ApplicationId':'appId','MaxBundleVersion':'1.1','MaxBuildVersion':'1.0'}, {'ApplicationId':'appId2','MaxBundleVersion':'3.2','MaxBuildVersion':'2.0'}]
</string><(Bool)/>
OpenAtLogin
This setting specifies whether OneDrive starts automatically when the user logs in.
![Macos App Bundle Arguments Dont Work Macos App Bundle Arguments Dont Work](/uploads/1/3/4/2/134276571/520546135.png)
If you set this setting's value to True, OneDrive starts automatically when the user logs in on Mac.
The example for this setting in the .plist file is:
<key>OpenAtLogin</key>
<(Bool)/>
<key>OpenAtLogin</key>
<(Bool)/>
SharePointOnPremFrontDoorUrl
This setting specifies the SharePoint Server 2019 on-premises URL that the OneDrive sync app must try to authenticate and sync against.
To enable this setting, you must define a string containing the URL of the on-premises SharePoint Server.
The example for this setting in the .plist file is:
<key>SharePointOnPremFrontDoorUrl</key>
<string>https://Contoso.SharePoint.com</string>
<key>SharePointOnPremFrontDoorUrl</key>
<string>https://Contoso.SharePoint.com</string>
SharePointOnPremPrioritizationPolicy
This setting determines whether or not the client should set up sync for SharePoint Server or SharePoint in Microsoft 365 first during the first-run scenario when the email is the same for both SharePoint Server on-premises and SharePoint in Microsoft 365 in a hybrid scenario.
If you set this setting's value to 1, it is an indication that OneDrive should set up SharePoint Server on-premises first, followed by SharePoint in Microsoft 365.
The example for this setting in the .plist file is:
<key>SharePointOnPremPrioritizationPolicy</key>
<int>(0 or 1)</int>
<key>SharePointOnPremPrioritizationPolicy</key>
<int>(0 or 1)</int>
SharePointOnPremTenantName
This setting enables you to specify the name of the folder created for syncing the SharePoint Server 2019 files specified in the Front Door URL.
If this setting is enabled, you can specify a TenantName which is the name the folder will use in the following convention:
OneDrive – TenantName (specified by you)
TenantName (specified by you)
OneDrive – TenantName (specified by you)
TenantName (specified by you)
If you do not specify any TenantName, the folder will use the first segment of the FrontDoorURL as the its name. For example, https://Contoso.SharePoint.com will use Contoso as the Tenant Name in the following convention:
OneDrive – Contoso
Contoso
OneDrive – Contoso
Contoso
The example for this setting in the .plist file is:
<key>SharePointOnPremTenantName</key>
<string>Contoso</string>
<key>SharePointOnPremTenantName</key>
<string>Contoso</string>
UploadBandwidthLimited
This setting defines the maximum upload throughput rate in KB/sec for computers running the OneDrive sync app.
See Full List On Wiki.octave.org
To enable this setting, set a value between 50 and 100,000 which is the upload throughput rate the sync app can use.
Bundle (macOS) - Wikipedia
The example for this setting in the .plist file is:
<key>UploadBandwidthLimited</key>
<int>(Upload Throughput Rate in KB/sec)</int>
<key>UploadBandwidthLimited</key>
<int>(Upload Throughput Rate in KB/sec)</int>
You can also configure the OneDrive Standalone sync app to receive delayed updates.
Qt For MacOS - Deployment | Qt 5.11
PList Location | Domain |
---|---|
~/Library/Preferences/com.microsoft.OneDriveUpdater.plist | com.microsoft.OneDriveUpdater |
Setting | Description | Parameters | Example Plist Entry |
---|---|---|---|
Tier | Defines the update ring for the computer | UpdateRing (String): This parameter has two different values. Production - The default update ring for OneDrive updates. Insiders - This update ring receives updates that are 'pre-production' and that allow you to play with features before they are released. Note that builds from this ring may be less stable. Enterprise - This update ring (now called 'Deferred') receives updates after they have been rolled out through the Production ring. It also lets you control the deployment of updates. For more information about the update rings and the procedure used by the sync app for checking for updates, see The OneDrive sync app update process. | <key>Tier</key> <string>(UpdateRing)</string> |