1 /* 2 * PROJECT: ReactOS system libraries 3 * LICENSE: GPL - See COPYING in the top level directory 4 * FILE: dll/shellext/stobject/hotplug.cpp 5 * PURPOSE: Removable devices notification icon handler 6 * PROGRAMMERS: Shriraj Sawant a.k.a SR13 <sr.official@hotmail.com> 7 */ 8 9 #include "precomp.h" 10 11 #include <atlsimpcoll.h> 12 #include <dbt.h> 13 #include <cfgmgr32.h> 14 #include <shlwapi.h> 15 16 #define DISPLAY_NAME_LEN 40 17 18 //BOOL WINAPI UnregisterDeviceNotification(HDEVNOTIFY Handle); 19 20 CSimpleArray<DEVINST> g_devList; 21 /*static HDEVNOTIFY g_hDevNotify = NULL;*/ 22 static HICON g_hIconHotplug = NULL; 23 static LPCWSTR g_strTooltip = L"Safely Remove Hardware and Eject Media"; 24 static WCHAR g_strMenuSel[DISPLAY_NAME_LEN]; 25 static BOOL g_IsRunning = FALSE; 26 static BOOL g_IsRemoving = FALSE; 27 28 /*++ 29 * @name EnumHotpluggedDevices 30 * 31 * Enumerates the connected safely removable devices. 32 * 33 * @param devList 34 * List of device instances, representing the currently attached devices. 35 * 36 * @return The error code. 37 * 38 *--*/ 39 HRESULT EnumHotpluggedDevices(CSimpleArray<DEVINST> &devList) 40 { 41 devList.RemoveAll(); // Clear current devList 42 HDEVINFO hdev = SetupDiGetClassDevs(NULL, NULL, 0, DIGCF_ALLCLASSES | DIGCF_PRESENT); 43 if (INVALID_HANDLE_VALUE == hdev) 44 return E_HANDLE; 45 SP_DEVINFO_DATA did = { 0 }; 46 did.cbSize = sizeof(did); 47 48 // Enumerate all the attached devices. 49 for (int idev = 0; SetupDiEnumDeviceInfo(hdev, idev, &did); idev++) 50 { 51 DWORD dwCapabilities = 0, dwSize = sizeof(dwCapabilities); 52 WCHAR dispName[DISPLAY_NAME_LEN]; 53 ULONG ulStatus = 0, ulPnum = 0, ulLength = DISPLAY_NAME_LEN * sizeof(WCHAR); 54 CONFIGRET cr = CM_Get_DevNode_Status(&ulStatus, &ulPnum, did.DevInst, 0); 55 if (cr != CR_SUCCESS) 56 continue; 57 cr = CM_Get_DevNode_Registry_Property(did.DevInst, CM_DRP_DEVICEDESC, NULL, dispName, &ulLength, 0); 58 if (cr != CR_SUCCESS) 59 continue; 60 cr = CM_Get_DevNode_Registry_Property(did.DevInst, CM_DRP_CAPABILITIES, NULL, &dwCapabilities, &dwSize, 0); 61 if (cr != CR_SUCCESS) 62 continue; 63 64 // Filter and make list of only the appropriate safely removable devices. 65 if ( (dwCapabilities & CM_DEVCAP_REMOVABLE) && 66 !(dwCapabilities & CM_DEVCAP_DOCKDEVICE) && 67 !(dwCapabilities & CM_DEVCAP_SURPRISEREMOVALOK) && 68 ((dwCapabilities & CM_DEVCAP_EJECTSUPPORTED) || (ulStatus & DN_DISABLEABLE)) && 69 !ulPnum) 70 { 71 devList.Add(did.DevInst); 72 } 73 } 74 SetupDiDestroyDeviceInfoList(hdev); 75 76 if (NO_ERROR != GetLastError() && ERROR_NO_MORE_ITEMS != GetLastError()) 77 { 78 return E_UNEXPECTED; 79 } 80 81 return S_OK; 82 } 83 84 /*++ 85 * @name NotifyBalloon 86 * 87 * Pops the balloon notification of the given notification icon. 88 * 89 * @param pSysTray 90 * Provides interface for acquiring CSysTray information as required. 91 * @param szTitle 92 * Title for the balloon notification. 93 * @param szInfo 94 * Main content for the balloon notification. 95 * @param uId 96 * Represents the particular notification icon. 97 * 98 * @return The error code. 99 * 100 *--*/ 101 HRESULT NotifyBalloon(CSysTray* pSysTray, LPCWSTR szTitle = NULL, LPCWSTR szInfo = NULL, UINT uId = ID_ICON_HOTPLUG) 102 { 103 NOTIFYICONDATA nim = { 0 }; 104 nim.cbSize = sizeof(NOTIFYICONDATA); 105 nim.uID = uId; 106 nim.hWnd = pSysTray->GetHWnd(); 107 108 nim.uFlags = NIF_INFO; 109 nim.uTimeout = 10; 110 nim.dwInfoFlags = NIIF_INFO; 111 112 StringCchCopy(nim.szInfoTitle, _countof(nim.szInfoTitle), szTitle); 113 StringCchCopy(nim.szInfo, _countof(nim.szInfo), szInfo); 114 BOOL ret = Shell_NotifyIcon(NIM_MODIFY, &nim); 115 116 Sleep(10000); /* As per windows, the balloon notification remains visible for atleast 10 sec. 117 This timer maintains the same condition. 118 Also it is required so that the icon doesn't hide instantly after last device is removed, 119 as that will prevent popping of notification. 120 */ 121 StringCchCopy(nim.szInfoTitle, _countof(nim.szInfoTitle), L""); 122 StringCchCopy(nim.szInfo, _countof(nim.szInfo), L""); 123 ret = Shell_NotifyIcon(NIM_MODIFY, &nim); 124 g_IsRemoving = FALSE; /* This flag is used to prevent instant icon hiding after last device is removed. 125 The above timer maintains the required state for the same. 126 */ 127 return ret ? S_OK : E_FAIL; 128 } 129 130 HRESULT STDMETHODCALLTYPE Hotplug_Init(_In_ CSysTray * pSysTray) 131 { 132 TRACE("Hotplug_Init\n"); 133 g_hIconHotplug = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_HOTPLUG_OK)); 134 g_IsRunning = TRUE; 135 EnumHotpluggedDevices(g_devList); 136 137 return pSysTray->NotifyIcon(NIM_ADD, ID_ICON_HOTPLUG, g_hIconHotplug, g_strTooltip, NIS_HIDDEN); 138 } 139 140 HRESULT STDMETHODCALLTYPE Hotplug_Update(_In_ CSysTray * pSysTray) 141 { 142 TRACE("Hotplug_Update\n"); 143 144 if(g_devList.GetSize() || g_IsRemoving) 145 return pSysTray->NotifyIcon(NIM_MODIFY, ID_ICON_HOTPLUG, g_hIconHotplug, g_strTooltip); 146 else 147 return pSysTray->NotifyIcon(NIM_MODIFY, ID_ICON_HOTPLUG, g_hIconHotplug, g_strTooltip, NIS_HIDDEN); 148 } 149 150 HRESULT STDMETHODCALLTYPE Hotplug_Shutdown(_In_ CSysTray * pSysTray) 151 { 152 TRACE("Hotplug_Shutdown\n"); 153 154 g_IsRunning = FALSE; 155 156 return pSysTray->NotifyIcon(NIM_DELETE, ID_ICON_HOTPLUG, NULL, NULL); 157 } 158 159 static void _RunHotplug(CSysTray * pSysTray) 160 { 161 ShellExecuteW(pSysTray->GetHWnd(), L"open", L"rundll32.exe shell32.dll,Control_RunDLL hotplug.dll", NULL, NULL, SW_SHOWNORMAL); 162 } 163 164 static void _ShowContextMenu(CSysTray * pSysTray) 165 { 166 HMENU hPopup = CreatePopupMenu(); 167 ULONG ulLength = DISPLAY_NAME_LEN * sizeof(WCHAR); 168 169 for (INT index = 0; index < g_devList.GetSize(); index++) 170 { 171 WCHAR dispName[DISPLAY_NAME_LEN], menuName[DISPLAY_NAME_LEN + 10]; 172 CONFIGRET cr = CM_Get_DevNode_Registry_Property(g_devList[index], CM_DRP_DEVICEDESC, NULL, dispName, &ulLength, 0); 173 if (cr != CR_SUCCESS) 174 StrCpyW(dispName, L"Unknown Device"); 175 176 swprintf(menuName, L"Eject %wS", dispName); 177 AppendMenuW(hPopup, MF_STRING, index+1, menuName); 178 } 179 180 SetForegroundWindow(pSysTray->GetHWnd()); 181 DWORD flags = TPM_RETURNCMD | TPM_NONOTIFY | TPM_RIGHTALIGN | TPM_BOTTOMALIGN; 182 POINT pt; 183 GetCursorPos(&pt); 184 185 DWORD id = TrackPopupMenuEx(hPopup, flags, 186 pt.x, pt.y, 187 pSysTray->GetHWnd(), NULL); 188 189 if (id > 0) 190 { 191 id--; // since array indices starts from zero. 192 CONFIGRET cr = CM_Get_DevNode_Registry_Property(g_devList[id], CM_DRP_DEVICEDESC, NULL, g_strMenuSel, &ulLength, 0); 193 if (cr != CR_SUCCESS) 194 StrCpyW(g_strMenuSel, L"Unknown Device"); 195 196 cr = CM_Request_Device_Eject_Ex(g_devList[id], 0, 0, 0, 0, 0); 197 if (cr != CR_SUCCESS) 198 { 199 WCHAR strInfo[128]; 200 swprintf(strInfo, L"Problem Ejecting %wS", g_strMenuSel); 201 MessageBox(0, L"The device cannot be stopped right now! Try stopping it again later!", strInfo, MB_OKCANCEL | MB_ICONEXCLAMATION); 202 } 203 else 204 { 205 //MessageBox(0, L"Device ejected successfully!! You can safely remove the device now!", L"Safely Remove Hardware", MB_OKCANCEL | MB_ICONINFORMATION); 206 g_IsRemoving = TRUE; 207 g_devList.RemoveAt(id); /* thing is.. even after removing id at this point, the devnode_change occurs after some seconds of sucessful removal 208 and since pendrive is still plugged in it gets enumerated, if problem number is not filtered. 209 */ 210 } 211 } 212 213 DestroyMenu(hPopup); 214 } 215 216 static void _ShowContextMenuR(CSysTray * pSysTray) 217 { 218 CString strMenu((LPWSTR)IDS_HOTPLUG_REMOVE_2); 219 HMENU hPopup = CreatePopupMenu(); 220 AppendMenuW(hPopup, MF_STRING, IDS_HOTPLUG_REMOVE_2, strMenu); 221 222 SetForegroundWindow(pSysTray->GetHWnd()); 223 DWORD flags = TPM_RETURNCMD | TPM_NONOTIFY | TPM_RIGHTALIGN | TPM_BOTTOMALIGN; 224 POINT pt; 225 GetCursorPos(&pt); 226 227 DWORD id = TrackPopupMenuEx(hPopup, flags, 228 pt.x, pt.y, 229 pSysTray->GetHWnd(), NULL); 230 231 if (id == IDS_HOTPLUG_REMOVE_2) 232 { 233 _RunHotplug(pSysTray); 234 } 235 236 DestroyMenu(hPopup); 237 } 238 239 HRESULT STDMETHODCALLTYPE Hotplug_Message(_In_ CSysTray * pSysTray, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT &lResult) 240 { 241 HRESULT hr = E_FAIL; 242 TRACE("Hotplug_Message uMsg=%d, wParam=%x, lParam=%x\n", uMsg, wParam, lParam); 243 244 switch (uMsg) 245 { 246 /*case WM_CREATE: 247 TRACE("Hotplug_Message: WM_CREATE\n"); 248 DEV_BROADCAST_DEVICEINTERFACE NotificationFilter; 249 250 ZeroMemory(&NotificationFilter, sizeof(NotificationFilter)); 251 NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE); 252 NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE; 253 254 g_hDevNotify = RegisterDeviceNotification(pSysTray->GetHWnd(), &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES); 255 if (g_hDevNotify != NULL) 256 { 257 lResult = true; 258 return S_OK; 259 } 260 return S_FALSE;*/ 261 262 case WM_USER + 220: 263 TRACE("Hotplug_Message: WM_USER+220\n"); 264 if (wParam == 1) 265 { 266 if (lParam == FALSE) 267 return Hotplug_Init(pSysTray); 268 else 269 return Hotplug_Shutdown(pSysTray); 270 } 271 return S_FALSE; 272 273 case WM_USER + 221: 274 TRACE("Hotplug_Message: WM_USER+221\n"); 275 if (wParam == 1) 276 { 277 lResult = (LRESULT)g_IsRunning; 278 return S_OK; 279 } 280 return S_FALSE; 281 282 case ID_ICON_HOTPLUG: 283 Hotplug_Update(pSysTray); 284 285 switch (lParam) 286 { 287 case WM_LBUTTONDOWN: 288 break; 289 290 case WM_LBUTTONUP: 291 _ShowContextMenu(pSysTray); 292 break; 293 294 case WM_LBUTTONDBLCLK: 295 _RunHotplug(pSysTray); 296 break; 297 298 case WM_RBUTTONDOWN: 299 break; 300 301 case WM_RBUTTONUP: 302 _ShowContextMenuR(pSysTray); 303 break; 304 305 case WM_RBUTTONDBLCLK: 306 break; 307 308 case WM_MOUSEMOVE: 309 break; 310 } 311 return S_OK; 312 313 case WM_DEVICECHANGE: 314 switch (wParam) 315 { 316 case DBT_DEVNODES_CHANGED: 317 hr = EnumHotpluggedDevices(g_devList); 318 if (FAILED(hr)) 319 return hr; 320 321 lResult = true; 322 break; 323 case DBT_DEVICEARRIVAL: 324 break; 325 case DBT_DEVICEQUERYREMOVE: 326 break; 327 case DBT_DEVICEQUERYREMOVEFAILED: 328 break; 329 case DBT_DEVICEREMOVECOMPLETE: 330 WCHAR strInfo[128]; 331 swprintf(strInfo, L"The %wS can now be safely removed from the system.", g_strMenuSel); 332 NotifyBalloon(pSysTray, L"Safe to Remove Hardware", strInfo); 333 334 lResult = true; 335 break; 336 case DBT_DEVICEREMOVEPENDING: 337 break; 338 } 339 return S_OK; 340 341 /*case WM_CLOSE: 342 if (!UnregisterDeviceNotification(hDeviceNotify)) 343 { 344 return S_FALSE; 345 } 346 return S_OK;*/ 347 348 default: 349 TRACE("Hotplug_Message received for unknown ID %d, ignoring.\n"); 350 return S_FALSE; 351 } 352 353 return S_FALSE; 354 } 355