Display the battery information

 Use this code to get Battery State

     dwResult = 1  AC State

     dwResult = 3  DC State          

1. DWORD GetBatteryState()
2.  {
3. #define GBS_HASBATTERY 0x1
4. #define GBS_ONBATTERY  0x2
5.   // Returned value includes GBS_HASBATTERY if the system has a 
6.   // non-UPS battery, and GBS_ONBATTERY if the system is running on 
7.   // a battery.
8.   //
9.   // dwResult & GBS_ONBATTERY means AC power has not been found.
10.   // dwResult & GBS_HASBATTERY means a non-UPS battery is being used.
12.   DWORD dwResult = GBS_ONBATTERY;
14.   // IOCTL_BATTERY_QUERY_INFORMATION,
15.   // enumerate the batteries and ask each one for information.
17.   HDEVINFO hdev =
18.             SetupDiGetClassDevs(&GUID_DEVCLASS_BATTERY, 
19.                                 0, 
20.                                 0, 
21.                                 DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
22.   if (INVALID_HANDLE_VALUE != hdev)
23.    {
24.     // Limit search to 100 batteries max
25.     for (int idev = 0; idev < 100; idev++)
26.      {
27.       SP_DEVICE_INTERFACE_DATA did = {0};
28.       did.cbSize = sizeof(did);
30.       if (SetupDiEnumDeviceInterfaces(hdev,
31.                                       0,
32.                                       &GUID_DEVCLASS_BATTERY,
33.                                       idev,
34.                                       &did))
35.        {
36.         DWORD cbRequired = 0;
38.         SetupDiGetDeviceInterfaceDetail(hdev,
39.                                         &did,
40.                                         0,
41.                                         0,
42.                                         &cbRequired,
43.                                         0);
44.         if (ERROR_INSUFFICIENT_BUFFER == GetLastError())
45.          {
46.           PSP_DEVICE_INTERFACE_DETAIL_DATA pdidd =
47.             (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LPTR,
48.                                                          cbRequired);
49.           if (pdidd)
50.            {
51.             pdidd->cbSize = sizeof(*pdidd);
52.             if (SetupDiGetDeviceInterfaceDetail(hdev,
53.                                                 &did,
54.                                                 pdidd,
55.                                                 cbRequired,
56.                                                 &cbRequired,
57.                                                 0))
58.              {
59.               // Enumerated a battery.  Ask it for information.
60.               HANDLE hBattery = 
61.                       CreateFile(pdidd->DevicePath,
62.                                  GENERIC_READ | GENERIC_WRITE,
63.                                  FILE_SHARE_READ | FILE_SHARE_WRITE,
64.                                  NULL,
65.                                  OPEN_EXISTING,
66.                                  FILE_ATTRIBUTE_NORMAL,
67.                                  NULL);
68.               if (INVALID_HANDLE_VALUE != hBattery)
69.                {
70.                 // Ask the battery for its tag.
71.                 BATTERY_QUERY_INFORMATION bqi = {0};
73.                 DWORD dwWait = 0;
74.                 DWORD dwOut;
76.                 if (DeviceIoControl(hBattery,
77.                                     IOCTL_BATTERY_QUERY_TAG,
78.                                     &dwWait,
79.                                     sizeof(dwWait),
80.                                     &bqi.BatteryTag,
81.                                     sizeof(bqi.BatteryTag),
82.                                     &dwOut,
83.                                     NULL)
84.                     && bqi.BatteryTag)
85.                  {
86.                   // With the tag, you can query the battery info.
87.                   BATTERY_INFORMATION bi = {0};
88.                   bqi.InformationLevel = BatteryInformation;
90.                   if (DeviceIoControl(hBattery,
91.                                       IOCTL_BATTERY_QUERY_INFORMATION,
92.                                       &bqi,
93.                                       sizeof(bqi),
94.                                       &bi,
95.                                       sizeof(bi),
96.                                       &dwOut,
97.                                       NULL))
98.                    {
99.                     // Only non-UPS system batteries count
100.                     if (bi.Capabilities & BATTERY_SYSTEM_BATTERY)
101.                      {
102.                       if (!(bi.Capabilities & BATTERY_IS_SHORT_TERM))
103.                        {
104.                         dwResult |= GBS_HASBATTERY;
105.                        }
107.                       // Query the battery status.
108.                       BATTERY_WAIT_STATUS bws = {0};
109.                       bws.BatteryTag = bqi.BatteryTag;
111.                       BATTERY_STATUS bs;
112.                       if (DeviceIoControl(hBattery,
113.                                           IOCTL_BATTERY_QUERY_STATUS,
114.                                           &bws,
115.                                           sizeof(bws),
116.                                           &bs,
117.                                           sizeof(bs),
118.                                           &dwOut,
119.                                           NULL))
120.                        {
121.                         if (bs.PowerState & BATTERY_POWER_ON_LINE)
122.                          {
123.                           dwResult &= ~GBS_ONBATTERY;
124.                          }
125.                        }
126.                      }
127.                    }
128.                  }
129.                 CloseHandle(hBattery);
130.                }
131.              }
132.             LocalFree(pdidd);
133.            }
134.          }
135.        }
136.         else  if (ERROR_NO_MORE_ITEMS == GetLastError())
137.          {
138.           break;  // Enumeration failed - perhaps there are no more items
139.          }
140.      }
141.     SetupDiDestroyDeviceInfoList(hdev);
142.    }
144.   //  Final cleanup:  If no battery is found, then presume that 
145.   //  AC power is being used.
147.   if (!(dwResult & GBS_HASBATTERY))
148.     dwResult &= ~GBS_ONBATTERY;
150.   return dwResult;
151.  }