macOS App Nap: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Overview
2	2
3	3		macOS 10.9 (Mavericks) introduced substantial power-saving features under the App Nap umbrella, especially for laptops. App Nap is based on several key principles:
4	4
5	5		- The features work without the developer needing to modify existing applications.
6	6		- The features keep the hardware as idle as possible given the demand for resources.
7	7		- When a Mac is on battery power, only the work the user requests or that is absolutely essential is done.
8	8
9	9		App Nap is activated by the operating system when:
10	10
11	11		- The application's windows are not visible; eg minimised to the dock or hidden by another application's window(s).
12	12		- The application has not updated any visible part of an open window for some time.
13	13		- The application is not playing audio.
14	14		- The application is not using OpenGL graphics.
15	15		- The application is in the background.
16	16		- The application has not informed macOS that it is still active via IOKit power management or NSProcessInfo assertions.
17	17
18	18		The App Nap power-saving measures include:
19	19
20	20		- Timer throttling: The frequency with which an application's timers are executed is reduced, increasing CPU idle time when running applications that, for example, check for data.
21	21
22	22		- I/O throttling: Disk and network activity is assigned the lowest priority for applications that are "napping" thereby reducing the speed at which the application can read/write data from/to a device. This also reduces the likelihood that a napping application will impact an application which is actively being used.
23	23
24	24		- Priority reduction: The UNIX process priority of an application is reduced so that it receives less available CPU time.
25	25
26	26		### Timer coalescing
27	27
28	28		Timer coalescing, although not an App Nap feature, was introduced in Mavericks at the same time. To maximise the amount of time that the CPU spends at idle, timer coalescing shifts the execution of timers by a small amount so that timers of multiple applications are executed at the same time. This is done by applying a time window to every timer based on the importance of the process. A timer can be executed at any time during this window, so may be shifted backward or forward a small amount so that it lines up with other timers that need to be executed at similar times. The timer windows are:
29	29
30	30		\| Process type \| Timer window \|
31	31		\|----------------------------\|--------------\|
32	32		\| Application (default) \| 1ms \|
33	33		\| System daemon \| 70-90ms \|
34	34		\| Background process \| 80-120ms \|
35	35		\| Critical/Real time process \| 0ms \|
36	36
37	37		The NSTimer class in Mavericks introduced a new tolerance parameter which enables developers to tune how timely timer-event driven events need to be.
38	38
39	39		## Managing App Nap
40	40
41	41		App Nap introduced a new API in NSProcessInfo which gives developers the ability to inform the operating system when an application is performing a long-running operation that may need to prevent App Nap or system sleep.
42	42
43	43		``` pascal
44	44		NSProcessInfoActivity = objccategory external (NSProcessInfo)
45	45		function beginActivityWithOptions_reason (options: NSActivityOptions; reason: NSString): NSObject; message 'beginActivityWithOptions:reason:';
46	46		procedure endActivity (activity: NSObject); message 'endActivity:';
47	47		procedure performActivityWithOptions_reason_usingBlock (options: NSActivityOptions; reason: NSString; block: OpaqueCBlock); message 'performActivityWithOptions:reason:usingBlock:';
48	48		```
49	49
50	50		Be aware that failing to execute endActivity after a beginActivityWithOptions for an extended period of time can have significant negative impacts on the performance of your user's computer, so only use the minimum amount of time required.
51	51
52	52		### Automatic termination
53	53
54	54		Automatic termination is a feature introduced in macOS 10.7 (Lion) that you must explicitly code for in your application. If it is enabled, then your application needs to save the current state of its user interface so that it can be restored later . The system can kill the underlying process for an auto-terminable application at any time, so saving this information maintains application continuity. The system usually kills an application’s underlying process some time after the user has closed all of its windows. However, the system may also kill an application with open windows if it is not currently visible on the screen.
55	55
56	56		To support automatic termination, you need to:
57	57
58	58		- Declare support for automatic termination either programmatically or setting the NSSupportsAutomaticTermination key value to YES in the application's `Info.plist` file.
59	59		- Support saving and restoring the application's window configurations.
60	60		- Save the user’s data at appropriate times.
61	61		- Single-window, library-style applications should implement strategies for saving data at appropriate checkpoints.
62	62		- Multiwindow, document-based applications can use the autosaving and saveless documents capabilities in NSDocument.
63	63
64	64		You can also use the App Nap API to control automatic termination.
65	65
66	66		``` pascal
67	67		function beginActivityWithOptions_reason (options: NSActivityOptions; reason: NSString): NSObjectProtocol; message 'beginActivityWithOptions:reason:';
68	68		// Perform some task
69	69		procedure endActivity (activity: NSObjectProtocol); message 'endActivity:';
70	70		```
71	71
72	72		is equivalent to:
73	73
74	74		``` pascal
75	75		procedure disbleAutomaticTermination (reason: NSString);
76	76		// Perform some task
77	77		procedure enableAutomaticTermination (reason: NSString);
78	78		```
79	79
80	80		## NSActivityOptions
81	81
82	82		\| Option \| Effect \|
83	83		\|----\|----\|
84	84		\| NSActivityIdleDisplaySleepDisabled \| require the screen to stay powered on \|
85	85		\| NSActivityIdleSystemSleepDisabled \| prevent idle sleep \|
86	86		\| NSActivitySuddenTerminationDisabled \| prevent sudden termination \|
87	87		\| NSActivityAutomaticTerminationDisabled \| prevent automatic termination \|
88	88		\| NSActivityUserInitiated \| indicate the application is performing a user-requested action \|
89	89		\| NSActivityUserInitiatedAllowingIdleSystemSleep \| indicate the application is performing a user-requested action, but that the system can sleep on idle \|
90	90		\| NSActivityBackground \| indicate the application has initiated some kind of work, but not as the direct result of user request \|
91	91		\| NSActivityLatencyCritical \| indicate the activity requires the highest amount of timer and I/O precision available \|
92	92
93	93		### Recommended usage
94	94
95	95		NSActivityUserInitiated: Used for finite length activities that the user has explicitly started. Examples include exporting or downloading a user specified file.
96	96
97	97		NSActivityBackground: Used for finite length activities that are part of the normal operation of your application but are not explicitly started by the user. Examples include autosaving, indexing, and automatic downloading of files.
98	98
99	99		NSActivityLatencyCritical: If your application requires high priority I/O, you can include the flag (using a bitwise OR). You should only use this flag for activities like audio or video recording that really do require high priority.
100	100
101	101		## Example code
102	102
103	103		``` pascal
104	104		unit Unit1;
105	105
106	106		{$mode objfpc}{$H+}
107	107		{$modeswitch objectivec1}
108	108
109	109		interface
110	110
111	111		uses
112	112		Classes, SysUtils, Forms, Dialogs, StdCtrls, ExtCtrls, CocoaAll;
113	113
114	114		{ NSProcessInfo }
115	115
116	116		type
117	117		NSProcessInfoActivity = objccategory external (NSProcessInfo)
118	118		function beginActivityWithOptions_reason (options: NSActivityOptions; reason: NSString): NSObjectProtocol; message 'beginActivityWithOptions:reason:'; { available in 10_9, 7_0 }
119	119		procedure endActivity (activity: NSObjectProtocol); message 'endActivity:'; { available in 10_9, 7_0 }
120	120		procedure performActivityWithOptions_reason_usingBlock (options: NSActivityOptions; reason: NSString; block: OpaqueCBlock); message 'performActivityWithOptions:reason:usingBlock:'; { available in 10_9, 7_0 }
121	121		end;
122	122
123	123		{ TForm1 }
124	124
125	125		TForm1 = Class(TForm)
126	126		Button1: TButton;
127	127		Button2: TButton;
128	128		Button3: TButton;
129	129		Memo1: TMemo;
130	130		procedure Button1Click(Sender: TObject);
131	131		procedure Button2Click(Sender: TObject);
132	132		procedure Button3Click(Sender: TObject);
133	133		private
134	134		public
135	135		end;
136	136
137	137		var
138	138		Form1: TForm1;
139	139		myActivityToken: NSObjectProtocol;
140	140
141	141		implementation
142	142
143	143		{$R *.lfm}
144	144
145	145		procedure TForm1.Button1Click(Sender: TObject);
146	146		begin
147	147		Form1.Memo1.Append('beginActivity');
148	148
149	149		myActivityToken := NSProcessInfo.processInfo.beginActivityWithOptions_reason((NSActivityIdleSystemSleepDisabled or NSActivityUserInitiated or NSActivityAutomaticTerminationDisabled), NSSTR('No napping!'));
150	150
151	151		if(myActivityToken = Nil) then
152	152		begin
153	153		Form1.Memo1.Append('No Token!');
154	154		end;
155	155
156	156		myActivityToken.retain;
157	157		end;
158	158
159	159		procedure TForm1.Button2Click(Sender: TObject);
160	160		begin
161	161		Form1.Memo1.Append('endActivity!');
162	162
163	163		if (myActivityToken <> Nil) then
164	164		begin
165	165		NSProcessinfo.processinfo.endActivity(myActivityToken);
166	166		myActivityToken.release;
167	167		myActivityToken := Nil;
168	168		end;
169	169		end;
170	170
171	171		procedure TForm1.Button3Click(Sender: TObject);
172	172		begin
173	173		Close;
174	174		end;
175	175
176	176		end.
177	177		```
178	178
179	179		## App Nap status
180	180
181	181		There are two ways of checking the App Nap status of your application.
182	182
183	183		### Method 1: Activity Monitor
184	184
185	185		Open Applications \> Utilities \> Activity Monitor which shows the status of App Nap for all running applications as well as other useful information like the energy impact of each application on the system:
186	186
187	187		![](/wiki-images/f/f9/Activity_Monitor_app_Nap.jpg)
188	188
189	189		### Method 2: pmset
190	190
191	191		Open an Applications \> Utilities \> Terminal and type the command:
192	192
193		-	~~`pmset -g assertionslog`~~
	193	+	```text
	194	+	pmset -g assertionslog
	195	+	```
194	196
195	197		which will produce the following output when you run the example code above and click the BeginActivity and EndActivity buttons.
196	198
197		-	`Time Action Type PID(Causing PID) ID Name `\
198		-	`==== ====== ==== ================ == ==== `\
199		-	`02/13 16:35:19 Created PreventUserIdleSystemSleep 1188 0x40e40001880f No napping! `\
200		-	~~`02/13 16:35:19 System wide status: PreventUserIdleSystemSleep: 1 `\~~
201		-	`02/13 16:35:29 Released PreventUserIdleSystemSleep 1188 0x40e40001880f No napping! `\
202		-	~~`02/13 16:35:29 System wide status: PreventUserIdleSystemSleep: 0`~~
	199	+	``` pascal
	200	+	Time Action Type PID(Causing PID) ID Name
	201	+	==== ====== ==== ================ == ====
	202	+	02/13 16:35:19 Created PreventUserIdleSystemSleep 1188 0x40e40001880f No napping!
	203	+	02/13 16:35:19 System wide status: PreventUserIdleSystemSleep: 1
	204	+	02/13 16:35:29 Released PreventUserIdleSystemSleep 1188 0x40e40001880f No napping!
	205	+	02/13 16:35:29 System wide status: PreventUserIdleSystemSleep: 0
	206	+	```
203	207
204	208		## Enhancing App Nap
205	209
206	210		While App Nap operates automatically, with very little effort you can enhance its capabilities by actively reducing your application's energy footprint and further lengthening the time users can use their battery-powered devices without needing to plug them into the power.
207	211
208	212		Your application knows best about the importance of its activity and should not rely on App Nap to put it into an idle state. The most effective way to enhance App Nap is for your application to listen for notifications that it’s no longer in active use and to reduce or suspend energy-intensive work as quickly as possible which can happen well before the system triggers App Nap automatically.
209	213
210	214		### Implement active application transition delegate methods
211	215
212	216		Implement NSApplicationDelegate methods in your application delegate to receive calls when the active state of your application — whether it’s in the foreground or not — changes.
213	217
214	218		\| Method \| When sent by the default notification center \| Significance \|
215	219		\|----\|----\|----\|
216	220		\| applicationWillResignActive \| Immediately before the application is deactivated and no longer the foreground (frontmost) application. \| Start winding down activity that can be stopped entirely once the change in state has completed. \|
217	221		\| applicationDidResignActive \| Immediately after the application is deactivated and gives up its position as the foreground application. \| Stop any power-intensive operations, animations, and UI updates as much as possible. \|
218	222		\| applicationWillBecomeActive \| Immediately before the application becomes active and comes to the front. \| Start resuming operations. \|
219	223		\| applicationDidBecomeActive \| Immediately after the application becomes active. \| Fully resume operations that were reduced or halted. \|
220	224
221	225		NSApplicationDelegate methods
222	226
223	227		#### Example code
224	228
225	229		In the example code below the relevant delegate methods simply log their occurrence. In a real application you would need to replace them with the desired behaviours to reduce or suspend relevant activities and restart activities as required.
226	230
227	231		``` pascal
228	232		unit Unit1;
229	233
230	234		{$mode objfpc}{$H+}
231	235		{$modeswitch objectivec1}
232	236
233	237		interface
234	238
235	239		uses
236	240		Forms, StdCtrls, CocoaAll;
237	241
238	242		type
239	243
240	244		{ TForm1 }
241	245
242	246		TForm1 = class(TForm)
243	247		Button1: TButton;
244	248		procedure Button1Click(Sender: TObject);
245	249		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
246	250		procedure FormCreate(Sender: TObject);
247	251		private
248	252
249	253		public
250	254
251	255		end;
252	256
253	257		{TMyAppDelegate}
254	258
255	259		TMyAppDelegate = objcclass(NSObject)
256	260		private
257	261
258	262		public
259	263		procedure applicationWillBecomeActive (aNotification: NSNotification);
260	264		message 'applicationWillBecomeActive:';
261	265		procedure applicationDidBecomeActive (aNotification: NSNotification);
262	266		message 'applicationDidBecomeActive:';
263	267		procedure applicationWillResignActive (aNotification: NSNotification);
264	268		message 'applicationWillResignActive:';
265	269		procedure applicationDidResignActive (aNotification: NSNotification);
266	270		message 'applicationDidResignActive:';
267	271		end;
268	272
269	273		var
270	274		Form1: TForm1;
271	275		myAppDelegate: TMyAppDelegate;
272	276
273	277		implementation
274	278
275	279		{$R *.lfm}
276	280
277	281		{NSApplication Delegates}
278	282
279	283		procedure TMyAppDelegate.applicationWillBecomeActive(aNotification: NSNotification);
280	284		begin
281	285		NSLog(NSStr('will become active'));
282	286		end;
283	287
284	288		procedure TMyAppDelegate.applicationDidBecomeActive(aNotification: NSNotification);
285	289		begin
286	290		NSLog(NSStr('did become active'));
287	291		end;
288	292
289	293		procedure TMyAppDelegate.applicationWillResignActive (aNotification: NSNotification);
290	294		begin
291	295		NSLog(NSStr('will resign active'));
292	296		end;
293	297		procedure TMyAppDelegate.applicationDidResignActive (aNotification: NSNotification);
294	298		begin
295	299		NSLog(NSStr('did resign active'));
296	300		end;
297	301
298	302		{Button Events}
299	303
300	304		procedure TForm1.Button1Click(Sender: TObject);
301	305		begin
302	306		NSLog(NSStr('Closing'));
303	307		Close;
304	308		end;
305	309
306	310		{Form Events}
307	311
308	312		procedure TForm1.FormCreate(Sender: TObject);
309	313		begin
310	314		// NSApp
311	315		// - The global variable for the shared application instance.
312	316		// NSApplication.sharedApplication
313	317		// - Returns the application instance, creating it if it doesn’t exist yet.
314	318		NSApp := NSApplication.sharedApplication;
315	319		NSApp.setDelegate(myAppDelegate);
316	320		end;
317	321
318	322		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
319	323		begin
320	324		if(NSApp.isActive) then
321	325		begin
322	326		NSLog(NSStr('Exiting'));
323	327		exit;
324	328		end
325	329		else
326	330		// needed if any part of form is occluded or does not quit
327	331		// until dock icon clicked when quitting via dock menu
328	332		begin
329	333		NSLog(NSStr('Closing2'));
330	334		Application.BringToFront;
331	335		CloseAction := TCloseAction.caFree;
332	336		end;
333	337		end;
334	338
335	339		Initialization
336	340		NSLog(NSStr('initialization'));
337	341		myAppDelegate := TMyAppDelegate.alloc.init;
338	342
339	343		Finalization
340	344		NSLog(NSStr('finalization'));
341	345		myAppDelegate.Release;
342	346		end.
343	347		```
344	348
345	349		Typical log output when the executable is started from an Applications \> Utilities \> Terminal:
346	350
347		-	~~`trev@macmini7 [/Users/trev/Programming/LAZARUS/laz_appnap_ex1] $ ./project1.app/Contents/MacOS/project1`\~~
348		-	~~`2021-03-01 17:57:40.293 project1[1695:130876] initialization`\~~
349		-	~~`2021-03-01 17:57:40.378 project1[1695:130876] will become active`\~~
350		-	~~`2021-03-01 17:57:40.379 project1[1695:130876] did become active`\~~
351		-	~~`2021-03-01 17:57:43.206 project1[1695:130876] will resign active`\~~
352		-	~~`2021-03-01 17:57:43.207 project1[1695:130876] did resign active`\~~
353		-	~~`2021-03-01 17:57:47.184 project1[1695:130876] Closing2`\~~
354		-	~~`2021-03-01 17:57:47.188 project1[1695:130876] will become active`\~~
355		-	~~`2021-03-01 17:57:47.189 project1[1695:130876] did become active`\~~
356		-	~~`2021-03-01 17:57:47.190 project1[1695:130876] finalization`~~
	351	+	```text
	352	+	trev@macmini7 [/Users/trev/Programming/LAZARUS/laz_appnap_ex1] $ ./project1.app/Contents/MacOS/project1
	353	+	2021-03-01 17:57:40.293 project1[1695:130876] initialization
	354	+	2021-03-01 17:57:40.378 project1[1695:130876] will become active
	355	+	2021-03-01 17:57:40.379 project1[1695:130876] did become active
	356	+	2021-03-01 17:57:43.206 project1[1695:130876] will resign active
	357	+	2021-03-01 17:57:43.207 project1[1695:130876] did resign active
	358	+	2021-03-01 17:57:47.184 project1[1695:130876] Closing2
	359	+	2021-03-01 17:57:47.188 project1[1695:130876] will become active
	360	+	2021-03-01 17:57:47.189 project1[1695:130876] did become active
	361	+	2021-03-01 17:57:47.190 project1[1695:130876] finalization
	362	+	```
357	363
358	364		Alternatively, you can view the output using the Applications \> Utilities \> Console.
359	365
360	366		### Register for application-level occlusion notifications
361	367
362	368		As soon as your application or any of its windows becomes hidden, your application should immediately halt any work that is no longer useful. When it becomes visible again, it can immediately refresh its content and resume any power-intensive operations.
363	369
364	370		Your application is considered hidden from the user when:
365	371
366	372		- Windows of other applications occlude the windows of your application.
367	373		- The screen saver is on and occluding all applications’ windows.
368	374		- Your application is in a Mission Control space where the user is not working.
369	375
370	376		applicationDidChangeOcclusionState tells the delegate that the application’s occlusion state changed.
371	377
372	378		On receiving this notification, you can query the application's occlusion state. Note that this only notifies about changes in the state of the occlusion, not when the occlusion region changes. You can use this notification to increase responsiveness and save power by halting any expensive calculations that the user cannot see.
373	379
374	380		If the NSApplicationOcclusionStateVisible global constant variable is set, it means that at least part of a window owned by your application is visible, so your application should continue working as normal. If the variable is not set, it means that no part of any window owned by your application is visible and your application should reduce or halt its operations and calculations because the user will not be able to see the results.
375	381
376	382		#### Example code
377	383
378	384		In the example code below the relevant delegate method simply logs its occurrence. In a real application you would need to replace it with the desired behaviour to reduce or suspend relevant activities and restart activities as required.
379	385
380	386		``` pascal
381	387		unit Unit1;
382	388
383	389		{$mode objfpc}{$H+}
384	390		{$modeswitch objectivec1}
385	391
386	392		interface
387	393
388	394		uses
389	395		Forms, StdCtrls, CocoaAll;
390	396
391	397		type
392	398
393	399		{ TForm1 }
394	400
395	401		TForm1 = class(TForm)
396	402		Button1: TButton;
397	403		procedure Button1Click(Sender: TObject);
398	404		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
399	405		procedure FormCreate(Sender: TObject);
400	406		private
401	407
402	408		public
403	409
404	410		end;
405	411
406	412		{TMyAppDelegate}
407	413
408	414		TMyAppDelegate = objcclass(NSObject)
409	415		private
410	416
411	417		public
412	418		procedure applicationDidChangeOcclusionState (aNotification: NSNotification);
413	419		message 'applicationDidChangeOcclusionState:';
414	420		end;
415	421
416	422		var
417	423		Form1: TForm1;
418	424		myAppDelegate: TMyAppDelegate;
419	425
420	426		implementation
421	427
422	428		{$R *.lfm}
423	429
424	430		{NSApplication Delegates}
425	431
426	432		procedure TMyAppDelegate.applicationDidChangeOcclusionState(aNotification: NSNotification);
427	433		begin
428	434		NSLog(NSStr('did change occlusion state'));
429	435
430	436		// if(NSApp.occlusionState AND NSApplicationOcclusionStateVisible) = 1 << 1 then // OR
431	437		if (NSApp.occlusionState AND NSApplicationOcclusionStateVisible) = %00000010 then
432	438		NSLog(NSStr('state: visible'))
433	439		else
434	440		NSLog(NSStr('state: invisible'))
435	441		end;
436	442
437	443		{Button Events}
438	444
439	445		procedure TForm1.Button1Click(Sender: TObject);
440	446		begin
441	447		NSLog(NSStr('Closing'));
442	448		Close;
443	449		end;
444	450
445	451		{Form Events}
446	452
447	453		procedure TForm1.FormCreate(Sender: TObject);
448	454		begin
449	455		// NSApp
450	456		// - The global variable for the shared application instance.
451	457		// NSApplication.sharedApplication
452	458		// - Returns the application instance, creating it if it doesn’t exist yet.
453	459		NSApp := NSApplication.sharedApplication;
454	460		NSApp.setDelegate(myAppDelegate);
455	461		end;
456	462
457	463		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
458	464		begin
459	465		if(NSApp.isActive) then
460	466		begin
461	467		NSLog(NSStr('Exiting'));
462	468		exit;
463	469		end
464	470		else
465	471		// needed if any part of form is occluded or does not quit
466	472		// until dock icon clicked when quitting via dock menu
467	473		begin
468	474		NSLog(NSStr('Closing2'));
469	475		Application.BringToFront;
470	476		CloseAction := TCloseAction.caFree;
471	477		end;
472	478		end;
473	479
474	480		Initialization
475	481		NSLog(NSStr('initialization'));
476	482		myAppDelegate := TMyAppDelegate.alloc.init;
477	483
478	484		Finalization
479	485		NSLog(NSStr('finalization'));
480	486		myAppDelegate.Release;
481	487		end.
482	488		```
483	489
484	490		Typical log output when the executable is started from an Applications \> Utilities \> Terminal:
485	491
486		-	~~`trev@macmini7 [/Users/trev/Programming/LAZARUS/laz_appnap_ex2] $ ./project1.app/Contents/MacOS/project1`\~~
487		-	~~`2021-03-01 18:25:51.348 project1[1894:139611] initialization`\~~
488		-	~~`2021-03-01 18:25:51.427 project1[1894:139611] did change occlusion state`\~~
489		-	~~`2021-03-01 18:25:51.427 project1[1894:139611] state: visible`\~~
490		-	~~`2021-03-01 18:25:55.842 project1[1894:139611] did change occlusion state`\~~
491		-	~~`2021-03-01 18:25:55.842 project1[1894:139611] state: invisible`\~~
492		-	~~`2021-03-01 18:26:00.552 project1[1894:139611] Closing2`\~~
493		-	~~`2021-03-01 18:26:00.558 project1[1894:139611] finalization`~~
	492	+	```text
	493	+	trev@macmini7 [/Users/trev/Programming/LAZARUS/laz_appnap_ex2] $ ./project1.app/Contents/MacOS/project1
	494	+	2021-03-01 18:25:51.348 project1[1894:139611] initialization
	495	+	2021-03-01 18:25:51.427 project1[1894:139611] did change occlusion state
	496	+	2021-03-01 18:25:51.427 project1[1894:139611] state: visible
	497	+	2021-03-01 18:25:55.842 project1[1894:139611] did change occlusion state
	498	+	2021-03-01 18:25:55.842 project1[1894:139611] state: invisible
	499	+	2021-03-01 18:26:00.552 project1[1894:139611] Closing2
	500	+	2021-03-01 18:26:00.558 project1[1894:139611] finalization
	501	+	```
494	502
495	503		Alternatively, you can view the output using the Applications \> Utilities \> Console.
496	504
497	505		## See also
498	506
499	507		- [[macOS Energy Efficiency Guide]]
500	508		- [[Accessing macOS System Information\|NSProcessInfo]] - accessing system information.
501	509
502	510		## External Links
503	511
504	512		- [Apple: Energy Efficiency Guide for Mac Apps](https://developer.apple.com/library/archive/documentation/Performance/Conceptual/power_efficiency_guidelines_osx/index.html#//apple_ref/doc/uid/TP40013929-CH15-SW1).
505	513		- [Apple: NSActivityOptions](https://developer.apple.com/documentation/foundation/nsactivityoptions).
506	514		- [Apple: NSProcessInfo](https://developer.apple.com/documentation/foundation/nsprocessinfo#/apple_ref/occ/cl/NSProcessInfo).
507	515		- [Apple: NSApplicationDelegate](https://developer.apple.com/documentation/appkit/nsapplicationdelegate).
508	516		- [Apple: NSApplicationDidChangeOcclusionStateNotification](https://developer.apple.com/documentation/appkit/nsapplicationocclusionstate/nsapplicationocclusionstatevisible).
509	517		- [Apple: NSTimer](https://developer.apple.com/documentation/foundation/nstimer).
510	518
511	519		---
512	520		From the Free Pascal wiki, page "macOS App Nap", as it stood on 2021-03-01 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history