Sinisa-Vuk_Mtp10

unit mtp_main;

interface

//*******************************************************************
//Created by sinisav (dec. 2013, feb. 2014) (http://www.experts-exchange.com/M_6334433.html)
//*******************************************************************

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, PortableDeviceApiLib_TLB, ActiveX, ComObj, ComCtrls;

// based upon following texts:

// http://cgeers.com/2011/05/22/enumerating-windows-portable-devices/
// http://cgeers.com/2011/06/05/wpd-enumerating-content/
// http://chocotooth.blogspot.com/2011/05/controlling-digital-camera-with-delphi_10.html
// http://chocotooth.blogspot.com/2011/07/controlling-digital-camera-with-delphi.html
// https://github.com/notpod/wpd-lib/blob/master/wpd-lib/WindowsPortableDevice.cs
// http://gzune.googlecode.com/svn/trunk/zUnlock/portabledeviceconstants.cs

// http://msdn.microsoft.com/en-us/library/ff597727.aspx

type
  TForm12 = class(TForm)
    ListBox1: TListBox;
    bListDev: TButton;
    bListAll: TButton;
    bCopyFrom: TButton;
    bDelete: TButton;
    SaveDialog1: TSaveDialog;
    bCopyTo: TButton;
    OpenDialog1: TOpenDialog;
    bListTop: TButton;
    Memo1: TMemo;
    Label1: TLabel;
    CheckBox1: TCheckBox;
    ListView1: TListView;
    bCopySpec: TButton;
    Edit1: TEdit;
    Label2: TLabel;
    Label3: TLabel;
    procedure bListDevClick(Sender: TObject);
    procedure bListAllClick(Sender: TObject);
    procedure bCopyFromClick(Sender: TObject);
    procedure bDeleteClick(Sender: TObject);
    procedure bCopyToClick(Sender: TObject);
    procedure bListTopClick(Sender: TObject);
    procedure ListBox1DblClick(Sender: TObject);
    procedure ListView1DblClick(Sender: TObject);
    procedure ListView1Editing(Sender: TObject; Item: TListItem;
      var AllowEdit: Boolean);
    procedure bCopySpecClick(Sender: TObject);
    procedure ListView1DrawItem(Sender: TCustomListView; Item: TListItem;
      Rect: TRect; State: TOwnerDrawState);
    procedure ListView1CustomDrawItem(Sender: TCustomListView; Item: TListItem;
      State: TCustomDrawState; var DefaultDraw: Boolean);
  private
    procedure AddLog(sText: String);
    procedure ClearLog;
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form12: TForm12;

implementation

uses Math;

{$R *.dfm}

procedure TForm12.ClearLog;
begin
  Memo1.Lines.Clear;
end;

procedure TForm12.AddLog(sText: String);
begin
  if CheckBox1.Checked then
    Memo1.Lines.Add(sText);
end;

procedure PropVariantInit(out pvar: PROPVARIANT);
begin
  ZeroMemory(@pvar, SizeOf(PROPVARIANT));
end;

procedure StringToPropVariant(sVal: WideString; var propvarValue: tag_inner_PROPVARIANT);
var
  pValues: IPortableDeviceValues;
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
begin
  pValues :=  CreateComObject(CLASS_PortableDeviceValues) as IPortableDeviceValues;
  if VarIsClear(pValues) then Exit;

  // string value into IPortableDeviceValues object
  dev_val.fmtid := WPD_OBJECT_ID_FMTID;
  dev_val.pid := WPD_OBJECT_ID_PID;
  pValues.SetStringValue(dev_val, PWideChar(sVal));

  // get back string into a PROPVARIANT
  pValues.GetValue(dev_val, propvarValue);

  pValues := nil;
end;

procedure PropVariantToString(propvarValue: tag_inner_PROPVARIANT; var sVal: WideString);
var
  pValues: IPortableDeviceValues;
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  hr: HResult;
  pVal: PWideChar;
begin
  sVal := '';
  pValues :=  CreateComObject(CLASS_PortableDeviceValues) as IPortableDeviceValues;
  if VarIsClear(pValues) then Exit;

  // PROPVARIANT into IPortableDeviceValues object
  dev_val.fmtid := WPD_OBJECT_ID_FMTID;
  dev_val.pid := WPD_OBJECT_ID_PID;
  pValues.SetValue(dev_val, propvarValue);

  //check if it is error code
  if propvarValue.vt = VT_ERROR then
  begin
    pValues.GetErrorValue(dev_val, hr);
    sVal := SysErrorMessage(hr);
  end
  else
  begin
    // get back string
    pValues.GetStringValue(dev_val, pVal);
    sVal := pVal;
  end;

  pValues := nil;
end;

function GetDevDescription(PMan: TPortableDeviceManager; sDeviceId: WideString): WideString;
var
  iDevNameLen: LongWord;
  iRes: Integer;
begin
  //get length of friendly name:
  iDevNameLen := 0;
  Result := '';

  iRes := PMan.GetDeviceDescription(PWideChar(sDeviceId), Word(nil^), iDevNameLen);
  if iRes = S_OK then
  begin
    Form12.AddLog('DeviceDescription len='+IntToStr(iDevNameLen));

    //Get Description
    if iDevNameLen>0 then
    begin
      SetLength(Result, iDevNameLen);
      ZeroMemory(PWideChar(Result), iDevNameLen);
      PMan.GetDeviceDescription(PWideChar(sDeviceId), PWord(PWideChar(Result))^, iDevNameLen);
      Result := Trim(Result);
      Form12.AddLog('DeviceDescription='+Result);
    end;
  end
  else
  begin
    Form12.AddLog('Cannot GetDeviceDescription! ('+IntToStr(iRes)+')');
  end;
end;

function GetFriendlyName(PMan: TPortableDeviceManager; sDeviceId: WideString): WideString;
var
  iDevNameLen{, iType}: LongWord;
  iRes: Integer;
begin
  //get length of friendly name:
  iDevNameLen := 0;
  Result := '';

  iRes := PMan.GetDeviceFriendlyName(PWideChar(sDeviceId), Word(nil^), iDevNameLen);
  if iRes = S_OK then
  begin
    Form12.AddLog('FriendlyName len='+IntToStr(iDevNameLen));

    //Get Friendly Name
    if iDevNameLen>0 then
    begin
      SetLength(Result, iDevNameLen);
      ZeroMemory(PWideChar(Result), iDevNameLen);
      PMan.GetDeviceFriendlyName(PWideChar(sDeviceId), PWord(PWideChar(Result))^, iDevNameLen);
      Result := Trim(Result);
      Form12.AddLog('FriendlyName='+Result);
    end;
  end
  else
  begin
    Form12.AddLog('Cannot GetDeviceFriendlyName! ('+IntToStr(iRes)+')');

    Result := GetDevDescription(PMan, sDeviceId);
  end;
end;

function DisplayObjectFormatDesc(format_id: WideString): String;
var
  g: TGuid;
begin
  Result := format_id;
  if format_id='' then Exit;

  try
    g := StringToGUID(format_id);

    if IsEqualGUID(WPD_OBJECT_FORMAT_3GP, g) then Result := 'WPD_OBJECT_FORMAT_3GP'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_AAC, g) then Result := 'WPD_OBJECT_FORMAT_AAC'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ABSTRACT_CONTACT, g) then Result := 'WPD_OBJECT_FORMAT_ABSTRACT_CONTACT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ABSTRACT_CONTACT_GROUP, g) then Result := 'WPD_OBJECT_FORMAT_ABSTRACT_CONTACT_GROUP'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ABSTRACT_MEDIA_CAST, g) then Result := 'WPD_OBJECT_FORMAT_ABSTRACT_MEDIA_CAST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_AIFF, g) then Result := 'WPD_OBJECT_FORMAT_AIFF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ALL, g) then Result := 'WPD_OBJECT_FORMAT_ALL'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ASF, g) then Result := 'WPD_OBJECT_FORMAT_ASF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ASXPLAYLIST, g) then Result := 'WPD_OBJECT_FORMAT_ASXPLAYLIST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_AUDIBLE, g) then Result := 'WPD_OBJECT_FORMAT_AUDIBLE'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_AVI, g) then Result := 'WPD_OBJECT_FORMAT_AVI'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_BMP, g) then Result := 'WPD_OBJECT_FORMAT_BMP'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_CIFF, g) then Result := 'WPD_OBJECT_FORMAT_CIFF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_DPOF, g) then Result := 'WPD_OBJECT_FORMAT_DPOF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_EXECUTABLE, g) then Result := 'WPD_OBJECT_FORMAT_EXECUTABLE'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_EXIF, g) then Result := 'WPD_OBJECT_FORMAT_EXIF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_FLAC, g) then Result := 'WPD_OBJECT_FORMAT_FLAC'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_FLASHPIX, g) then Result := 'WPD_OBJECT_FORMAT_FLASHPIX'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_GIF, g) then Result := 'WPD_OBJECT_FORMAT_GIF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_HTML, g) then Result := 'WPD_OBJECT_FORMAT_HTML'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ICALENDAR, g) then Result := 'WPD_OBJECT_FORMAT_ICALENDAR'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_ICON, g) then Result := 'WPD_OBJECT_FORMAT_ICON'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_JFIF, g) then Result := 'WPD_OBJECT_FORMAT_JFIF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_JP2, g) then Result := 'WPD_OBJECT_FORMAT_JP2'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_JPX, g) then Result := 'WPD_OBJECT_FORMAT_JPX'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_M3UPLAYLIST, g) then Result := 'WPD_OBJECT_FORMAT_M3UPLAYLIST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_M4A, g) then Result := 'WPD_OBJECT_FORMAT_M4A'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MHT_COMPILED_HTML, g) then Result := 'WPD_OBJECT_FORMAT_MHT_COMPILED_HTML'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MICROSOFT_EXCEL, g) then Result := 'WPD_OBJECT_FORMAT_MICROSOFT_EXCEL'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MICROSOFT_POWERPOINT, g) then Result := 'WPD_OBJECT_FORMAT_MICROSOFT_POWERPOINT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MICROSOFT_WFC, g) then Result := 'WPD_OBJECT_FORMAT_MICROSOFT_WFC'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MICROSOFT_WORD, g) then Result := 'WPD_OBJECT_FORMAT_MICROSOFT_WORD'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MP2, g) then Result := 'WPD_OBJECT_FORMAT_MP2'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MP3, g) then Result := 'WPD_OBJECT_FORMAT_MP3'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MP4, g) then Result := 'WPD_OBJECT_FORMAT_MP4'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MPEG, g) then Result := 'WPD_OBJECT_FORMAT_MPEG'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_MPLPLAYLIST, g) then Result := 'WPD_OBJECT_FORMAT_MPLPLAYLIST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_NETWORK_ASSOCIATION, g) then Result := 'WPD_OBJECT_FORMAT_NETWORK_ASSOCIATION'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_OGG, g) then Result := 'WPD_OBJECT_FORMAT_OGG'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_PCD, g) then Result := 'WPD_OBJECT_FORMAT_PCD'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_PICT, g) then Result := 'WPD_OBJECT_FORMAT_PICT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_PLSPLAYLIST, g) then Result := 'WPD_OBJECT_FORMAT_PLSPLAYLIST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_PNG, g) then Result := 'WPD_OBJECT_FORMAT_PNG'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_PROPERTIES_ONLY, g) then Result := 'WPD_OBJECT_FORMAT_PROPERTIES_ONLY'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_SCRIPT, g) then Result := 'WPD_OBJECT_FORMAT_SCRIPT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_TEXT, g) then Result := 'WPD_OBJECT_FORMAT_TEXT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_TIFF, g) then Result := 'WPD_OBJECT_FORMAT_TIFF'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_TIFFEP, g) then Result := 'WPD_OBJECT_FORMAT_TIFFEP'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_TIFFIT, g) then Result := 'WPD_OBJECT_FORMAT_TIFFIT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_UNSPECIFIED, g) then Result := 'WPD_OBJECT_FORMAT_UNSPECIFIED'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_VCALENDAR1, g) then Result := 'WPD_OBJECT_FORMAT_VCALENDAR1'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_VCARD2, g) then Result := 'WPD_OBJECT_FORMAT_VCARD2'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_VCARD3, g) then Result := 'WPD_OBJECT_FORMAT_VCARD3'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WAVE, g) then Result := 'WPD_OBJECT_FORMAT_WAVE'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WINDOWSIMAGEFORMAT, g) then Result := 'WPD_OBJECT_FORMAT_WINDOWSIMAGEFORMAT'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WMA, g) then Result := 'WPD_OBJECT_FORMAT_WMA'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WMV, g) then Result := 'WPD_OBJECT_FORMAT_WMV'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WPLPLAYLIST, g) then Result := 'WPD_OBJECT_FORMAT_WPLPLAYLIST'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_X509V3CERTIFICATE, g) then Result := 'WPD_OBJECT_FORMAT_X509V3CERTIFICATE'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_XML, g) then Result := 'WPD_OBJECT_FORMAT_XML'
    else if IsEqualGUID(WPD_OBJECT_FORMAT_WMV, g) then Result := 'WPD_OBJECT_FORMAT_WMV';
  except
  end;
end;

function DisplayFunctionalCategory(cat_id: WideString): String;
var
  g: TGuid;
begin
  Result := cat_id;
  if cat_id='' then Exit;

  try
    g := StringToGUID(cat_id);

    if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_ALL, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_ALL'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_AUDIO_CAPTURE, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_AUDIO_CAPTURE'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_DEVICE, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_DEVICE'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_NETWORK_CONFIGURATION, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_NETWORK_CONFIGURATION'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_RENDERING_INFORMATION, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_RENDERING_INFORMATION'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_SMS, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_SMS'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_STILL_IMAGE_CAPTURE, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_STILL_IMAGE_CAPTURE'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_STORAGE, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_STORAGE'
    else if IsEqualGUID(WPD_FUNCTIONAL_CATEGORY_VIDEO_CAPTURE, g) then Result := 'WPD_FUNCTIONAL_CATEGORY_VIDEO_CAPTURE';
  except
  end;
end;

function DisplayContentType(content_id: WideString): String;
var
  g: TGuid;
begin
  Result := content_id;
  if content_id='' then Exit;

  try
    g := StringToGUID(content_id);

    if IsEqualGUID(WPD_CONTENT_TYPE_ALL, g) then Result := 'WPD_CONTENT_TYPE_ALL'
    else if IsEqualGUID(WPD_CONTENT_TYPE_APPOINTMENT, g) then Result := 'WPD_CONTENT_TYPE_APPOINTMENT'
    else if IsEqualGUID(WPD_CONTENT_TYPE_AUDIO, g) then Result := 'WPD_CONTENT_TYPE_AUDIO'
    else if IsEqualGUID(WPD_CONTENT_TYPE_AUDIO_ALBUM, g) then Result := 'WPD_CONTENT_TYPE_AUDIO_ALBUM'
    else if IsEqualGUID(WPD_CONTENT_TYPE_CALENDAR, g) then Result := 'WPD_CONTENT_TYPE_CALENDAR'
    else if IsEqualGUID(WPD_CONTENT_TYPE_CERTIFICATE, g) then Result := 'WPD_CONTENT_TYPE_CERTIFICATE'
    else if IsEqualGUID(WPD_CONTENT_TYPE_CONTACT, g) then Result := 'WPD_CONTENT_TYPE_CONTACT'
    else if IsEqualGUID(WPD_CONTENT_TYPE_CONTACT_GROUP, g) then Result := 'WPD_CONTENT_TYPE_CONTACT_GROUP'
    else if IsEqualGUID(WPD_CONTENT_TYPE_DOCUMENT, g) then Result := 'WPD_CONTENT_TYPE_DOCUMENT'
    else if IsEqualGUID(WPD_CONTENT_TYPE_EMAIL, g) then Result := 'WPD_CONTENT_TYPE_EMAIL'
    else if IsEqualGUID(WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT, g) then Result := 'WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT'
    else if IsEqualGUID(WPD_CONTENT_TYPE_GENERIC_FILE, g) then Result := 'WPD_CONTENT_TYPE_GENERIC_FILE'
    else if IsEqualGUID(WPD_CONTENT_TYPE_GENERIC_MESSAGE, g) then Result := 'WPD_CONTENT_TYPE_GENERIC_MESSAGE'
    else if IsEqualGUID(WPD_CONTENT_TYPE_IMAGE, g) then Result := 'WPD_CONTENT_TYPE_IMAGE'
    else if IsEqualGUID(WPD_CONTENT_TYPE_IMAGE_ALBUM, g) then Result := 'WPD_CONTENT_TYPE_IMAGE_ALBUM'
    else if IsEqualGUID(WPD_CONTENT_TYPE_MEDIA_CAST, g) then Result := 'WPD_CONTENT_TYPE_MEDIA_CAST'
    else if IsEqualGUID(WPD_CONTENT_TYPE_MEMO, g) then Result := 'WPD_CONTENT_TYPE_MEMO'
    else if IsEqualGUID(WPD_CONTENT_TYPE_MIXED_CONTENT_ALBUM, g) then Result := 'WPD_CONTENT_TYPE_MIXED_CONTENT_ALBUM'
    else if IsEqualGUID(WPD_CONTENT_TYPE_NETWORK_ASSOCIATION, g) then Result := 'WPD_CONTENT_TYPE_NETWORK_ASSOCIATION'
    else if IsEqualGUID(WPD_CONTENT_TYPE_PLAYLIST, g) then Result := 'WPD_CONTENT_TYPE_PLAYLIST'
    else if IsEqualGUID(WPD_CONTENT_TYPE_PROGRAM, g) then Result := 'WPD_CONTENT_TYPE_PROGRAM'
    else if IsEqualGUID(WPD_CONTENT_TYPE_SECTION, g) then Result := 'WPD_CONTENT_TYPE_SECTION'
    else if IsEqualGUID(WPD_CONTENT_TYPE_TASK, g) then Result := 'WPD_CONTENT_TYPE_TASK'
    else if IsEqualGUID(WPD_CONTENT_TYPE_TELEVISION, g) then Result := 'WPD_CONTENT_TYPE_TELEVISION'
    else if IsEqualGUID(WPD_CONTENT_TYPE_UNSPECIFIED, g) then Result := 'WPD_CONTENT_TYPE_UNSPECIFIED'
    else if IsEqualGUID(WPD_CONTENT_TYPE_VIDEO, g) then Result := 'WPD_CONTENT_TYPE_VIDEO'
    else if IsEqualGUID(WPD_CONTENT_TYPE_VIDEO_ALBUM, g) then Result := 'WPD_CONTENT_TYPE_VIDEO_ALBUM'
    else if IsEqualGUID(WPD_CONTENT_TYPE_WIRELESS_PROFILE, g) then Result := 'WPD_CONTENT_TYPE_WIRELESS_PROFILE'
    else if IsEqualGUID(WPD_CONTENT_TYPE_FOLDER, g) then Result := 'WPD_CONTENT_TYPE_FOLDER'
    ;
  except
  end;
end;

function DisplaySupportedCommand(g: TGuid): String;
begin
  Result := GUIDToString(g);

  try
    if IsEqualGUID(WPD_CATEGORY_COMMON, g) then Result := 'WPD_CATEGORY_COMMON'
    else if IsEqualGUID(WPD_CATEGORY_CAPABILITIES, g) then Result := 'WPD_CATEGORY_CAPABILITIES'
    else if IsEqualGUID(WPD_CATEGORY_DEVICE_HINTS, g) then Result := 'WPD_CATEGORY_DEVICE_HINTS'
    else if IsEqualGUID(WPD_CATEGORY_MEDIA_CAPTURE, g) then Result := 'WPD_CATEGORY_MEDIA_CAPTURE'
    else if IsEqualGUID(WPD_CATEGORY_NETWORK_CONFIGURATION, g) then Result := 'WPD_CATEGORY_NETWORK_CONFIGURATION'
    else if IsEqualGUID(WPD_CATEGORY_NULL, g) then Result := 'WPD_CATEGORY_NULL'
    else if IsEqualGUID(WPD_CATEGORY_OBJECT_ENUMERATION, g) then Result := 'WPD_CATEGORY_OBJECT_ENUMERATION'
    else if IsEqualGUID(WPD_CATEGORY_OBJECT_MANAGEMENT, g) then Result := 'WPD_CATEGORY_OBJECT_MANAGEMENT'
    else if IsEqualGUID(WPD_CATEGORY_OBJECT_PROPERTIES, g) then Result := 'WPD_CATEGORY_OBJECT_PROPERTIES'
    else if IsEqualGUID(WPD_CATEGORY_OBJECT_PROPERTIES_BULK, g) then Result := 'WPD_CATEGORY_OBJECT_PROPERTIES_BULK'
    else if IsEqualGUID(WPD_CATEGORY_OBJECT_RESOURCES, g) then Result := 'WPD_CATEGORY_OBJECT_RESOURCES'
    else if IsEqualGUID(WPD_CATEGORY_SERVICE_CAPABILITIES, g) then Result := 'WPD_CATEGORY_SERVICE_CAPABILITIES'
    else if IsEqualGUID(WPD_CATEGORY_SERVICE_COMMON, g) then Result := 'WPD_CATEGORY_SERVICE_COMMON'
    else if IsEqualGUID(WPD_CATEGORY_SERVICE_METHODS, g) then Result := 'WPD_CATEGORY_SERVICE_METHODS'
    else if IsEqualGUID(WPD_CATEGORY_SMS, g) then Result := 'WPD_CATEGORY_SMS'
    else if IsEqualGUID(WPD_CATEGORY_STILL_IMAGE_CAPTURE, g) then Result := 'WPD_CATEGORY_STILL_IMAGE_CAPTURE'
    else if IsEqualGUID(WPD_CATEGORY_STORAGE, g) then Result := 'WPD_CATEGORY_STORAGE'
    ;
  except
  end;
end;

procedure EnumContentsProperties(parentID: WideString; prop: IPortableDeviceProperties);
var
  ObjVal: PWideChar;
  propKeys: IPortableDeviceKeyCollection;
  prop_val: IPortableDeviceValues;
  propKeys_val: PortableDeviceApiLib_TLB._tagpropertykey;
begin
  if not VarIsClear(prop) then
  begin
    propKeys := CreateComObject(CLSID_PortableDeviceKeyCollection) as IPortableDeviceKeyCollection;
    if VarIsClear(propKeys) then Exit;

    //add props we want
    propKeys_val.fmtid := WPD_OBJECT_PARENT_ID_FMTID;
    propKeys_val.pid := WPD_OBJECT_PARENT_ID_PID;
    propKeys.Add(propKeys_val);

    propKeys_val.fmtid := WPD_OBJECT_NAME_FMTID;
    propKeys_val.pid := WPD_OBJECT_NAME_PID;
    propKeys.Add(propKeys_val);

    propKeys_val.fmtid := WPD_OBJECT_PERSISTENT_UNIQUE_ID_FMTID;
    propKeys_val.pid := WPD_OBJECT_PERSISTENT_UNIQUE_ID_PID;
    propKeys.Add(propKeys_val);

    propKeys_val.fmtid := WPD_OBJECT_FORMAT_FMTID;
    propKeys_val.pid := WPD_OBJECT_FORMAT_PID;
    propKeys.Add(propKeys_val);

    propKeys_val.fmtid := WPD_OBJECT_CONTENT_TYPE_FMTID;
    propKeys_val.pid := WPD_OBJECT_CONTENT_TYPE_PID;
    propKeys.Add(propKeys_val);

    prop.GetValues(PWideChar(parentID), propKeys, prop_val);
    if not VarIsClear(prop_val) then
    begin
      propKeys_val.fmtid := WPD_OBJECT_PARENT_ID_FMTID;
      propKeys_val.pid := WPD_OBJECT_PARENT_ID_PID;

      prop_val.GetStringValue(propKeys_val, ObjVal);
      Form12.AddLog('WPD_OBJECT_PARENT_ID: '+ ObjVal);

      propKeys_val.fmtid := WPD_OBJECT_NAME_FMTID;
      propKeys_val.pid := WPD_OBJECT_NAME_PID;

      prop_val.GetStringValue(propKeys_val, ObjVal);
      Form12.AddLog('WPD_OBJECT_NAME: '+ ObjVal);

      propKeys_val.fmtid := WPD_OBJECT_PERSISTENT_UNIQUE_ID_FMTID;
      propKeys_val.pid := WPD_OBJECT_PERSISTENT_UNIQUE_ID_PID;

      prop_val.GetStringValue(propKeys_val, ObjVal);
      Form12.AddLog('WPD_OBJECT_PERSISTENT_UNIQUE_ID: '+ ObjVal);

      propKeys_val.fmtid := WPD_OBJECT_FORMAT_FMTID;
      propKeys_val.pid := WPD_OBJECT_FORMAT_PID;

      prop_val.GetStringValue(propKeys_val, ObjVal);
      Form12.AddLog('WPD_OBJECT_FORMAT: '+ DisplayObjectFormatDesc(ObjVal));

      propKeys_val.fmtid := WPD_OBJECT_CONTENT_TYPE_FMTID;
      propKeys_val.pid := WPD_OBJECT_CONTENT_TYPE_PID;

      prop_val.GetStringValue(propKeys_val, ObjVal);
      Form12.AddLog('WPD_OBJECT_CONTENT_TYPE: '+ DisplayContentType(ObjVal));
    end;
  end;
end;

procedure EnumFunctionalCategoryObjects(capabilities: IPortableDeviceCapabilities; sCat: WideString);
var
  sResultText: WideString;
  pCategoryObjs: IPortableDevicePropVariantCollection;
  iCount, i: Cardinal;
  prop_var: tag_inner_PROPVARIANT;
  gCat: TGuid;
begin
  if sCat='' then Exit;

  if not VarIsClear(capabilities) then
  begin
    gCat := StringToGUID(sCat);
    try
      pCategoryObjs := CreateComObject(CLASS_PortableDevicePropVariantCollection) as IPortableDevicePropVariantCollection;
      if VarIsClear(pCategoryObjs) then Exit;

      capabilities.GetFunctionalObjects(gCat, pCategoryObjs);

      pCategoryObjs.GetCount(iCount);
      Form12.AddLog('Functional Category Objects Count: '+IntToStr(iCount));

      if iCount>0 then
      begin
        for i := 0 to iCount-1 do
        begin
          PropVariantInit(ActiveX.PROPVARIANT(prop_var));
          pCategoryObjs.GetAt(i, prop_var);
          PropVariantToString(prop_var, sResultText);
          Form12.AddLog('Functional Category Object: '+sResultText);
        end;
      end;
    except
    end;
  end;
end;

procedure EnumContentTypes(capabilities: IPortableDeviceCapabilities; sCat: WideString);
var
  sResultText: WideString;
  contentTypes: IPortableDevicePropVariantCollection;
  iCount, i: Cardinal;
  prop_var: tag_inner_PROPVARIANT;
  gCat: TGuid;
begin
  if sCat='' then Exit;

  if not VarIsClear(capabilities) then
  begin
    gCat := StringToGUID(sCat);
    try
      contentTypes := CreateComObject(CLASS_PortableDevicePropVariantCollection) as IPortableDevicePropVariantCollection;
      if VarIsClear(contentTypes) then Exit;

      capabilities.GetSupportedContentTypes(gCat, contentTypes);

      contentTypes.GetCount(iCount);
      Form12.AddLog('Content Types Count: '+IntToStr(iCount));

      if iCount>0 then
      begin
        for i := 0 to iCount-1 do
        begin
          PropVariantInit(ActiveX.PROPVARIANT(prop_var));
          contentTypes.GetAt(i, prop_var);
          PropVariantToString(prop_var, sResultText);
          Form12.AddLog('Content Type: '+DisplayContentType(sResultText));
        end;
      end;
    except
    end;
  end;
end;

procedure EnumSupportedCommands(capabilities: IPortableDeviceCapabilities);
var
  CmdKeys: IPortableDeviceKeyCollection;
  iCount, i: Cardinal;
  cmd_key: PortableDeviceApiLib_TLB._tagpropertykey;
begin
  if not VarIsClear(capabilities) then
  begin
    try
      CmdKeys := CreateComObject(CLSID_PortableDeviceKeyCollection) as IPortableDeviceKeyCollection;
      if VarIsClear(CmdKeys) then Exit;

      capabilities.GetSupportedCommands(CmdKeys);

      CmdKeys.GetCount(iCount);
      Form12.AddLog('Supported Commands Count: '+IntToStr(iCount));

      if iCount>0 then
      begin
        for i := 0 to iCount-1 do
        begin
          CmdKeys.GetAt(i, cmd_key);
          Form12.AddLog('Supported Command: '+DisplaySupportedCommand(cmd_key.fmtid)+' ('+IntToStr(cmd_key.pid)+')');
        end;
      end;
    except
    end;
  end;
end;

procedure EnumDevCapabilities(PortableDev: IPortableDevice);
var
  sResultText: WideString;
  capabilities: IPortableDeviceCapabilities;
  pCategories: IPortableDevicePropVariantCollection;
  iCount, i: Cardinal;
  prop_var: tag_inner_PROPVARIANT;
begin
  if not VarIsClear(PortableDev) then
  begin
    try
      PortableDev.Capabilities(capabilities);
      if not VarIsClear(capabilities) then
      begin
        pCategories := CreateComObject(CLASS_PortableDevicePropVariantCollection) as IPortableDevicePropVariantCollection;
        if VarIsClear(pCategories) then Exit;

        capabilities.GetFunctionalCategories(pCategories);

        pCategories.GetCount(iCount);
        Form12.AddLog('Dev. Functional Categories Count: '+IntToStr(iCount));

        if iCount>0 then
        begin
          for i := 0 to iCount-1 do
          begin
            //list categories
            PropVariantInit(ActiveX.PROPVARIANT(prop_var));
            pCategories.GetAt(i, prop_var);
            PropVariantToString(prop_var, sResultText);
            Form12.AddLog('Dev. Functional Category: '+DisplayFunctionalCategory(sResultText));
            //category objects....
            EnumFunctionalCategoryObjects(capabilities, sResultText);
            //types...
            EnumContentTypes(capabilities, sResultText);
          end;
        end;
        //comands....
        EnumSupportedCommands(capabilities);
      end;
    finally
      capabilities := nil;
    end;
  end;
end;

const
  CLIENT_NAME : WideString = 'MyClient';
  CLIENT_MAJOR_VER = 1;
  CLIENT_MINOR_VER = 0;
  CLIENT_REVISION  = 0;

function ConnectToDevice(sDev: WideString; var PortableDev: IPortableDevice): Boolean;
var
  PortableDeviceValues: IPortableDeviceValues;
  hr: HResult;
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  //bReadonly: Boolean;
begin
  Result := False;

  Form12.AddLog('Start Connecting: '+sDev);

  PortableDev := CoPortableDevice.Create;
  try
     //create device values:
    PortableDeviceValues := CreateComObject(CLASS_PortableDeviceValues) as IPortableDeviceValues;
    if VarIsClear(PortableDeviceValues) then Exit;
    Form12.AddLog('Dev. val. ok! ');

    //bReadonly := False;
    //set some info
    dev_val.fmtid := WPD_CLIENT_NAME_FMTID;
    dev_val.pid := WPD_CLIENT_NAME_PID;
    PortableDeviceValues.SetStringValue(dev_val, PWideChar(CLIENT_NAME));

    dev_val.fmtid := WPD_CLIENT_MAJOR_VERSION_FMTID;
    dev_val.pid := WPD_CLIENT_MAJOR_VERSION_PID;
    PortableDeviceValues.SetUnsignedIntegerValue(dev_val, CLIENT_MAJOR_VER);

    dev_val.fmtid := WPD_CLIENT_MINOR_VERSION_FMTID;
    dev_val.pid := WPD_CLIENT_MINOR_VERSION_PID;
    PortableDeviceValues.SetUnsignedIntegerValue(dev_val, CLIENT_MINOR_VER);

    dev_val.fmtid := WPD_CLIENT_REVISION_FMTID;
    dev_val.pid := WPD_CLIENT_REVISION_PID;
    PortableDeviceValues.SetUnsignedIntegerValue(dev_val, CLIENT_REVISION);

    //open device
    hr := PortableDev.Open(PWideChar(sDev), PortableDeviceValues);
    if hr = E_ACCESSDENIED then
    begin
      // Attempt to open for read-only access
      dev_val.fmtid := WPD_CLIENT_DESIRED_ACCESS_FMTID;
      dev_val.pid := WPD_CLIENT_DESIRED_ACCESS_PID;
      PortableDeviceValues.SetUnsignedIntegerValue(dev_val, GENERIC_READ);
      hr := PortableDev.Open(PWideChar(sDev), PortableDeviceValues);
      //bReadonly := (hr = S_OK);
    end;

    //opened ok
    if hr = S_OK then
    begin
      Form12.AddLog('Connected: '+sDev);
      Result := True;
    end
    else
    begin
      Form12.AddLog('Not connected: '+IntToStr(hr));
    end;
  finally
    PortableDeviceValues := nil;
  end;
end;

procedure TForm12.bListDevClick(Sender: TObject);
var
  PMan: TPortableDeviceManager;
  iDevCount: LongWord;
  pDevs: array of PWideChar;
  i, iRes: Integer;
  DevFriendlyName: WideString;
  PortableDev: IPortableDevice;
begin
  ClearLog;
  ListBox1.Items.Clear;
  ListView1.Items.Clear;
  AddLog('+++++ '+bListDev.Caption+' +++++');

  try
    PMan := TPortableDeviceManager.Create(nil);
    try
      if PMan.RefreshDeviceList = S_OK then
      begin
        // Determine how many WPD devices are connected
        iDevCount := 1;
        if PMan.GetDevices(PWideChar(nil^), iDevCount) = S_OK then
        begin
          AddLog('Devices found: '+ IntToStr(iDevCount));

          if iDevCount>0 then
          begin
            // Retrieve the device id for each connected device
            AddLog('Prepare dev. list');
            SetLength(pDevs, iDevCount);
            AddLog('Call: GetDevices');
            iRes := PMan.GetDevices(pDevs[0], iDevCount);
            AddLog('Result = '+ IntToStr(iRes));
            if iRes = S_OK then
            begin
              AddLog('Start looping....');
              for i := 0 to iDevCount - 1 do //enumerate the devices:
              begin
                AddLog('dev id='+Trim(pDevs[i]));

                //get length of friendly name:
                DevFriendlyName := GetFriendlyName(PMan, pDevs[i]);

                ListBox1.Items.Add(DevFriendlyName + '  ' + Trim(pDevs[i])); //keep dev id 4 later

                //list of cap.
                try
                  if ConnectToDevice(pDevs[i], PortableDev) then
                  begin
                    EnumDevCapabilities(PortableDev);
                    PortableDev.Close;
                  end;
                finally
                  PortableDev := nil;
                end;
              end;
            end
            else
              AddLog('Cannot get device info! ('+IntToStr(iRes)+')');
          end;
        end;
      end;
    finally
      PMan.Free;
    end;
  except
    on E: Exception do
    begin
      AddLog('Exception: ('+E.Message+')');
    end;
  end;

  if ListBox1.Items.Count>0 then
    ListBox1.ItemIndex := 0;
end;

function IsDirectory(prop_val: IPortableDeviceValues): Boolean;
var
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  prop_guid: TGUID;
begin
  Result := False;

  if not VarIsClear(prop_val) then
  begin
    dev_val.fmtid := WPD_OBJECT_CONTENT_TYPE_FMTID;
    dev_val.pid := WPD_OBJECT_CONTENT_TYPE_PID;
    if prop_val.GetGuidValue(dev_val, prop_guid) = S_OK then
    begin
      if IsEqualGUID(prop_guid, WPD_CONTENT_TYPE_FOLDER) or
        IsEqualGUID(prop_guid, WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT)
      then
        Result := True;
    end;
  end;
end;

function IsDrive(sObjName: WideString): Boolean;
begin
  Result := (ExtractFilePath(sObjName) = sObjName);
end;

function GetFirstStorageID(PortableDev: IPortableDevice): WideString;
var
  content: IPortableDeviceContent;
  objectIds: IEnumPortableDeviceObjectIDs;
  objectId: PWideChar;
  fetched: Cardinal;
begin
  Result := WPD_DEVICE_OBJECT_ID;
  if PortableDev.Content(content) = S_OK then
  begin
    if content.EnumObjects(0, '', nil, objectIds) = S_OK then
    begin
      objectIds.Reset;
      objectIds.Next(1, objectId, fetched);
      if (fetched > 0) then
        Result := objectId;
    end;
  end;

  Form12.AddLog('Device root: '+ Result);
end;

procedure EnumContentsOfFolder(content: IPortableDeviceContent; parentID: WideString;
  lst: TListItems; bGoDeep: Boolean; ParentPath: WideString);
var
  objectIds: IEnumPortableDeviceObjectIDs;
  objectId, ObjName, ObjOrigName: PWideChar;
  fetched, total: Cardinal;
  keys: IPortableDeviceKeyCollection;
  prop: IPortableDeviceProperties;
  prop_val: IPortableDeviceValues;
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  bFolder: Boolean;
  itm: TListItem;
  //prop_guid: TGUID;
  ObjectPath: WideString;
begin
  if not VarIsClear(content) then
  begin
    //get content properties
    content.Properties(prop);
    EnumContentsProperties(parentID, prop);

    if content.EnumObjects(0, PWideChar(parentID), nil, objectIds) = S_OK then
    begin
      total := 0;
      Form12.AddLog('Enumerate: '+parentID);
      repeat
        objectIds.Next(1, objectId, fetched);
        Inc(total, fetched);
      until fetched=0;
      Form12.AddLog('Enum count: '+IntToStr(total));

      objectIds.Reset;
      repeat
        objectIds.Next(1, objectId, fetched);
        if (fetched > 0) then
        begin
          //Get object prop.
          prop.GetSupportedProperties(objectId, keys);
          prop.GetValues(objectId, keys, prop_val);
          ObjName := '';
          ObjOrigName := '';

          // Get the name of the object
          if not VarIsClear(prop_val) then
          begin
            dev_val.fmtid := WPD_OBJECT_ORIGINAL_FILE_NAME_FMTID;
            dev_val.pid := WPD_OBJECT_ORIGINAL_FILE_NAME_PID;

            prop_val.GetStringValue(dev_val, ObjOrigName);
            if Length(Trim(ObjOrigName)) = 0 then
              ObjOrigName := objectId;

            dev_val.fmtid := WPD_OBJECT_NAME_FMTID;
            dev_val.pid := WPD_OBJECT_NAME_PID;

            prop_val.GetStringValue(dev_val, ObjName);
          end;

          bFolder := IsDirectory(prop_val); //include zip folders
          if Length(ParentPath) > 0 then
            ObjectPath := IncludeTrailingPathDelimiter(ParentPath) + ObjName
          else
            ObjectPath := ObjName;

          //keep name
          itm := lst.Add;
          itm.Caption := ObjOrigName; //keep folder/file name
          itm.SubItems.Add(objectId);  //obj id - full path to object
          itm.SubItems.Add(ObjName); //obj name
          itm.SubItems.Add(ObjectPath); //full path to object
          itm.Data := Pointer(ifthen(bFolder, 1, 0));

          //go into subfolder
          if bFolder and bGoDeep then
          begin
            Form12.AddLog('Go deep...');
            EnumContentsOfFolder(content, objectId, lst, bGoDeep, ObjectPath);
          end;
        end;
      until fetched=0;
    end;
  end;
end;

function LocateSpecifiedFolder(content: IPortableDeviceContent; parentID: WideString;
  sFindFolder, sParent: WideString; var sDestFolder: WideString): Boolean;
var
  objectIds: IEnumPortableDeviceObjectIDs;
  objectId, ObjName, ObjOrigName: PWideChar;
  fetched, total: Cardinal;
  keys: IPortableDeviceKeyCollection;
  prop: IPortableDeviceProperties;
  prop_val: IPortableDeviceValues;
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  bFolder: Boolean;
  sCurrent: WideString;
begin
  Result := False;

  if (not VarIsClear(content)) and (Length(sFindFolder) > 0) then
  begin
    //get content properties
    content.Properties(prop);
    EnumContentsProperties(parentID, prop);

    if content.EnumObjects(0, PWideChar(parentID), nil, objectIds) = S_OK then
    begin
      total := 0;
      Form12.AddLog('Enumerate: '+parentID);
      repeat
        objectIds.Next(1, objectId, fetched);
        Inc(total, fetched);
      until fetched=0;
      Form12.AddLog('Enum count: '+IntToStr(total));

      objectIds.Reset;
      repeat
        objectIds.Next(1, objectId, fetched);
        if (fetched > 0) then
        begin
          //Get object prop.
          prop.GetSupportedProperties(objectId, keys);
          prop.GetValues(objectId, keys, prop_val);
          ObjName := '';
          ObjOrigName := '';

          // Get the name of the object
          if not VarIsClear(prop_val) then
          begin
            dev_val.fmtid := WPD_OBJECT_ORIGINAL_FILE_NAME_FMTID;
            dev_val.pid := WPD_OBJECT_ORIGINAL_FILE_NAME_PID;

            prop_val.GetStringValue(dev_val, ObjOrigName);
            if Length(Trim(ObjOrigName)) = 0 then
              ObjOrigName := objectId;

            dev_val.fmtid := WPD_OBJECT_NAME_FMTID;
            dev_val.pid := WPD_OBJECT_NAME_PID;

            prop_val.GetStringValue(dev_val, ObjName);
          end;

          bFolder := IsDirectory(prop_val); //include zip folders
          if sParent<>'' then
            sCurrent := IncludeTrailingPathDelimiter(sParent)+ObjOrigName
          else
            sCurrent := ObjOrigName;

          if Pos(UpperCase(sCurrent), UpperCase(sFindFolder)) > 0 then
          begin
            if Length(sCurrent) >= Length(sFindFolder) then
            begin
              sDestFolder := objectId;
              Result := True;
            end
            else
            begin
              //go into subfolder
              if bFolder then
              begin
                Form12.AddLog('Go deep...');
                Result := LocateSpecifiedFolder(content, objectId, sFindFolder,
                  sCurrent, sDestFolder);
              end;
            end;
          end;
        end;
      until fetched=0;
    end;
  end;
end;

procedure ListFilesOnDevice(sDev: WideString; lst: TListItems; sParent: WideString;
  bGoDeep: Boolean);
var
  PortableDev: IPortableDevice;
  content: IPortableDeviceContent;
  sPath: String;
begin
  try
    if ConnectToDevice(sDev, PortableDev) then
    begin
      //read content of device
      try
        if PortableDev.Content(content) = S_OK then
        begin
          sPath := sParent;
          if sParent='' then
          begin
            sPath := '';
            sParent := GetFirstStorageID(PortableDev);
          end;

          EnumContentsOfFolder(content, sParent, lst, bGoDeep, sPath);
        end;
      finally
        PortableDev.Close;
      end;
    end;
  finally
    PortableDev := nil;
  end;
end;

function FindFolderOnDevice(sDev: WideString; sParent, sFindFolder: WideString;
  var sDestFolder: WideString): Boolean;
var
  PortableDev: IPortableDevice;
  content: IPortableDeviceContent;
begin
  Result := False;
  sDestFolder := '';
  try
    if ConnectToDevice(sDev, PortableDev) then
    begin
      //read content of device
      try
        if PortableDev.Content(content) = S_OK then
        begin
          if sParent='' then
            sParent := GetFirstStorageID(PortableDev);

          Result := LocateSpecifiedFolder(content, sParent, sFindFolder, '', sDestFolder);
        end;
      finally
        PortableDev.Close;
      end;
    end;
  finally
    PortableDev := nil;
  end;
end;

procedure TForm12.bListAllClick(Sender: TObject);
var
  sDevId: WideString;
begin
  AddLog('+++++ '+bListTop.Caption+' +++++');

  if ListBox1.ItemIndex >= 0 then
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));

    ListView1.Items.Clear;
    ListView1.Items.BeginUpdate;
    try
      ListFilesOnDevice(sDevId, ListView1.Items, '', True);
    finally
      ListView1.Items.EndUpdate;
    end;
  end;
end;

function GetFileFromDevice(sDeviceId, sFile, sSaveAs: WideString): Boolean;
var
  PortableDev: IPortableDevice;
  content: IPortableDeviceContent;
  resources: IPortableDeviceResources;
  iTransferSize, iReadBytes: Cardinal;
  res_prop: PortableDeviceApiLib_TLB._tagpropertykey;
  fDevStream: PortableDeviceApiLib_TLB.IStream;
  fFileStream: TFileStream;
  buf: array[0..(1024-1)] of Byte;
begin
  Result := False;
  try
    if ConnectToDevice(sDeviceId, PortableDev) then
    begin
      //read content of device
      try
        if PortableDev.Content(content) = S_OK then
        begin
          Form12.AddLog('Content: OK');

          if content.Transfer(resources) = S_OK then
          begin
            iTransferSize := 0;
            res_prop.fmtid := WPD_RESOURCE_DEFAULT_FMTID;
            res_prop.pid := WPD_RESOURCE_DEFAULT_PID;
            //request stream
            if resources.GetStream(PWideChar(sFile), res_prop, 0, iTransferSize, fDevStream) = S_OK then
            begin
              Form12.AddLog('Stream: OK');

              fFileStream := TFileStream.Create(sSaveAs, fmCreate);
              try
                //read source stream using buffer
                repeat
                  fDevStream.RemoteRead(buf[0], 1024, iReadBytes);
                  if iReadBytes>0 then
                    fFileStream.Write(buf[0], iReadBytes);
                until (iReadBytes = 0);

                Result := True;
              finally
                fFileStream.Free;
              end;
            end;
          end;
        end;
      finally
        fDevStream := nil;
        PortableDev.Close;
      end;
    end;
  finally
    PortableDev := nil;
  end;
end;

procedure TForm12.bCopyFromClick(Sender: TObject);
var
  sDevId, sFile: WideString;
begin
  AddLog('+++++ '+bCopyFrom.Caption+' +++++');

  if (ListBox1.ItemIndex >= 0) and (ListView1.ItemIndex >= 0) and
    (Cardinal(ListView1.Items.Item[ListView1.ItemIndex].Data) = 0) then //if is file
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));
    //file id
    sFile := ListView1.Items.Item[ListView1.ItemIndex].SubItems[0];

    //get destination directory
    SaveDialog1.FileName := ExtractFileName(ListView1.Items.Item[ListView1.ItemIndex].Caption);
    if SaveDialog1.Execute then
    begin
      GetFileFromDevice(sDevId, sFile, SaveDialog1.FileName);
    end;
  end;
end;

function DelFileFromDevice(sDeviceId, sFile: WideString; bWithRecursion: Boolean;
  var sResultText: WideString): Boolean;
var
  PortableDev: IPortableDevice;
  content: IPortableDeviceContent;
  prop_var: tag_inner_PROPVARIANT;
  pFiles, pRes: IPortableDevicePropVariantCollection;
  iCount: Cardinal;
begin
  Result := False;
  sResultText := '';
  try
    if ConnectToDevice(sDeviceId, PortableDev) then
    begin
      //read content of device
      try
        if PortableDev.Content(content) = S_OK then
        begin
          pFiles := CreateComObject(CLASS_PortableDevicePropVariantCollection) as IPortableDevicePropVariantCollection;
          if VarIsClear(pFiles) then Exit;

          pRes := CreateComObject(CLASS_PortableDevicePropVariantCollection) as IPortableDevicePropVariantCollection;
          if VarIsClear(pRes) then Exit;

          //add  file name to list for deleting
          PropVariantInit(ActiveX.PROPVARIANT(prop_var));
          StringToPropVariant(sFile, prop_var);
          pFiles.Add(prop_var);

          Form12.AddLog('Try to delete: '+sFile);
          //delete
          Result := (content.Delete(Math.IfThen(bWithRecursion, 1, 0), pFiles, pRes) = S_OK); //recursion ??

          pRes.GetCount(iCount);
          if iCount>0 then
          begin
            PropVariantInit(ActiveX.PROPVARIANT(prop_var));
            pRes.GetAt(0, prop_var);
            PropVariantToString(prop_var, sResultText);

            Form12.AddLog('Delete: '+sResultText);
          end;
        end;
      finally
        PortableDev.Close;
      end;
    end;
  finally
    pFiles := nil;
    pRes := nil;
    PortableDev := nil;
  end;
end;

procedure TForm12.bDeleteClick(Sender: TObject);
var
  sDevId, sFile, sResultText: WideString;
begin
  AddLog('+++++ '+bDelete.Caption+' +++++');

  if (ListBox1.ItemIndex >= 0) and (ListView1.ItemIndex >= 0) and
    (Cardinal(ListView1.Items.Item[ListView1.ItemIndex].Data) = 0) then  //if is file
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));
    //file
    sFile := ListView1.Items.Item[ListView1.ItemIndex].SubItems[0];

    //delete
    if MessageDlg('Want to delete?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then
    begin
      DelFileFromDevice(sDevId, sFile, True, sResultText);
      ShowMessage(sResultText);
    end;
  end;
end;

procedure GetRequiredPropertiesForContent(parent: WideString; FileName: WideString;
  iSize: Cardinal; var ppObjectProperties: IPortableDeviceValues);
var
  dev_val: PortableDeviceApiLib_TLB._tagpropertykey;
  //prop_guid: TGUID;
begin
  //parent id
  dev_val.fmtid := WPD_OBJECT_PARENT_ID_FMTID;
  dev_val.pid := WPD_OBJECT_PARENT_ID_PID;
  ppObjectProperties.SetStringValue(dev_val, PWideChar(parent));

  //object name
  dev_val.fmtid := WPD_OBJECT_NAME_FMTID;
  dev_val.pid := WPD_OBJECT_NAME_PID;
  ppObjectProperties.SetStringValue(dev_val, PWideChar(FileName));

  //file name
  dev_val.fmtid := WPD_OBJECT_ORIGINAL_FILE_NAME_FMTID;
  dev_val.pid := WPD_OBJECT_ORIGINAL_FILE_NAME_PID;
  ppObjectProperties.SetStringValue(dev_val, PWideChar(FileName));

  //size
  dev_val.fmtid := WPD_OBJECT_SIZE_FMTID;
  dev_val.pid := WPD_OBJECT_SIZE_PID;
  ppObjectProperties.SetUnsignedLargeIntegerValue(dev_val, iSize);

  {dev_val.fmtid := WPD_OBJECT_CONTENT_TYPE_FMTID;
  dev_val.pid := WPD_OBJECT_CONTENT_TYPE_PID;
  prop_guid := WPD_CONTENT_TYPE_FOLDER;
  ppObjectProperties.SetGuidValue(dev_val, prop_guid);}
end;

function TransferFileToDevice(sDeviceId, sFile, sSaveTo: WideString): Boolean;
var
  PortableDev: IPortableDevice;
  content: IPortableDeviceContent;
  iTransferSize, iReadBytes, iWritten: Cardinal;
  fDevStream: PortableDeviceApiLib_TLB.IStream;
  pValues: IPortableDeviceValues;
  fFileStream: TFileStream;
  buf: array[0..(1024-1)] of Byte;
  ppszCookie: PWideChar;
  iRes: Integer;
begin
  Result := False;
  try
    if ConnectToDevice(sDeviceId, PortableDev) then
    begin
      //read content of device
      try
        if PortableDev.Content(content) = S_OK then
        begin
          //required properties for content
          pValues :=  CreateComObject(CLASS_PortableDeviceValues) as IPortableDeviceValues;
          if VarIsClear(pValues) then Exit;

          Form12.AddLog('Try to copy to dev: '+sFile+ ' - dest: '+sSaveTo);

          fFileStream := TFileStream.Create(sFile, fmOpenRead);
          try
            GetRequiredPropertiesForContent(sSaveTo, ExtractFileName(sFile),
              fFileStream.Size, pValues);

            //create dest. stream
            iTransferSize := 0;
            content.CreateObjectWithPropertiesAndData(pValues, fDevStream, iTransferSize, ppszCookie);
            if VarIsClear(fDevStream) then Exit;

            Form12.AddLog('Stream: OK');

            //transfer to dev. stream
            //read source stream using buffer
            repeat
              iReadBytes := fFileStream.Read(buf[0], 1024);
              Form12.AddLog('File - readed bytes: ' + IntToStr(iReadBytes));
              if iReadBytes>0 then
              begin
               iRes := fDevStream.RemoteWrite(buf[0], iReadBytes, iWritten);
               if iRes <> S_OK then
                 Form12.AddLog('Error writing: ' + IntToStr(iRes));
              end;
            until (iReadBytes = 0);

            //commit saving to stream
            Result := (fDevStream.Commit(0) = S_OK);
            if Result then
              Form12.AddLog('File Commit ok!')
            else
              Form12.AddLog('File Commit nok!');
          finally
            fFileStream.Free;
          end;
        end;
      finally
        fDevStream := nil;
        PortableDev.Close;
      end;
    end;
  finally
    PortableDev := nil;
  end;
end;

procedure TForm12.bCopyToClick(Sender: TObject);
var
  sDevId, sFile, sFolder: WideString;
begin
  AddLog('+++++ '+bCopyTo.Caption+' +++++');

  if (ListBox1.ItemIndex >= 0) then
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));

    if OpenDialog1.Execute then
    begin
      //file
      sFile := OpenDialog1.FileName;
      //dest. folder
      sFolder := '';
      if (ListView1.ItemIndex >= 0) then
      begin
        //folder is marked in TObject
        sFolder := ListView1.Items.Item[ListView1.ItemIndex].SubItems[0];

        if Integer(ListView1.Items.Item[ListView1.ItemIndex].Data)=0 then //is no folder
        begin
          sFolder := ExcludeTrailingPathDelimiter(ExtractFilePath(sFolder));
        end;
      end
      else
      begin
        //get main folder ....
        if ListView1.Items.Count > 0 then
        begin
          sFolder := ListView1.Items.Item[0].SubItems[0];
          sFolder := ExcludeTrailingPathDelimiter(ExtractFilePath(sFolder));
        end;
      end;

      AddLog('Want transfer to: ' + sFolder);

      //transfer to destination folder
      if TransferFileToDevice(sDevId, sFile, sFolder) then
        ShowMessage('Saved!')
      else
        ShowMessage('Error!');
    end;
  end;
end;

procedure TForm12.bListTopClick(Sender: TObject);
var
  sDevId, sParent: WideString;
begin
  if Sender <> nil then
    AddLog('+++++ '+bListTop.Caption+' +++++');

  if ListBox1.ItemIndex >= 0 then
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));

    sParent := '';
    if (ListView1.ItemIndex>=0) and (Sender = nil) then
    begin
      sParent := ListView1.Items.Item[ListView1.ItemIndex].SubItems[0];
      if Cardinal(ListView1.Items.Item[ListView1.ItemIndex].Data) = 0 then Exit;//is not folder
    end;

    ListView1.Items.Clear;
    ListView1.Items.BeginUpdate;
    try
      ListFilesOnDevice(sDevId, ListView1.Items, sParent, False);
    finally
      ListView1.Items.EndUpdate;
    end;
  end;
end;

procedure TForm12.bCopySpecClick(Sender: TObject);
var
  sDevId, sFile, sFolder: WideString;
begin
  AddLog('+++++ '+bCopySpec.Caption+' +++++');

  if (ListBox1.ItemIndex >= 0) then
  begin
    //extract dev id
    sDevId := ListBox1.Items[ListBox1.ItemIndex];
    sDevId := Trim(Copy(sDevId, Pos(DEV_START_PATH, sDevId), Length(sDevId)));

    if OpenDialog1.Execute then
    begin
      //file
      sFile := OpenDialog1.FileName;
      //dest. folder
      if FindFolderOnDevice(sDevId, '', Edit1.Text, sFolder) then
      begin
        AddLog('Folder found: ' + sFolder);
        //transfer to destination folder
        if TransferFileToDevice(sDevId, sFile, sFolder) then
          ShowMessage('Saved!')
        else
          ShowMessage('Error!');
      end
      else
        ShowMessage('Cannot locate destination folder!');
    end;
  end
  else
    ShowMessage('Please, select a device!');
end;

procedure TForm12.ListBox1DblClick(Sender: TObject);
begin
  bListTopClick(bListTop);
end;

procedure TForm12.ListView1CustomDrawItem(Sender: TCustomListView;
  Item: TListItem; State: TCustomDrawState; var DefaultDraw: Boolean);
begin
  DefaultDraw := True; //draw by default engine anyway
  Sender.Canvas.Font.Color := clBlack;

  if Cardinal(Item.Data) > 0 then //is folder?
  begin
    Sender.Canvas.Font.Color := clMaroon;
  end;
end;

procedure TForm12.ListView1DblClick(Sender: TObject);
begin
  //maybe file is dbl clked
  if (ListView1.ItemIndex >= 0) and (Cardinal(ListView1.Items.Item[ListView1.ItemIndex].Data) = 0) then
  begin
    bCopyFromClick(nil);
  end
  else
  begin
    AddLog('+++++ List specific folder +++++');
    bListTopClick(nil);
  end;
end;

procedure TForm12.ListView1DrawItem(Sender: TCustomListView; Item: TListItem;
  Rect: TRect; State: TOwnerDrawState);
begin
  //
end;

procedure TForm12.ListView1Editing(Sender: TObject; Item: TListItem;
  var AllowEdit: Boolean);
begin
  AllowEdit := False;
end;

initialization
  OleInitialize(nil);

finalization
  OleUninitialize;

end.