El Directorio Home en tus aplicaciones Android


Resultado de imagen de directorio home

Para obtener la carpeta "Home" en rad studio XE10 tendremos que utilizar la función GetHomePath (function GetHomePath: string; static), que está en la unit System.IOutils.

Esta función devuelve la ruta de acceso principal del usuario. Si la llamada a la función genera un error, devolverá una cadena vacía. 
Si queremos guardar un fichero podríamos hacerlo de la siguiente manera:

 TFile.WriteAllText (TPath. GetHomePath () + TPath. DirectorySeparatorChar + 'sample.txt', 'Este es mi texto de ejemplo.');

-Ubicaciones de la ruta home en función del Sistema Operativo.: 
Windows: apunta a la carpeta User's application 
MacOSx: apunta a users home folder, definida por la variable $Home 
IOS y Android: apunta a la localización de la sandbox de la app, que se define para cada instancia de la aplicación y para cada dispositivo IOS.
PlataformaPathPath ID
Windows XPC:\Documents and Settings\Application DataCSIDL_APPDATA
Windows Vistaor laterC:\Documents and Settings\AppData\RoamingFOLDERID_RoamingAppData
Mac OS X/Users/NSUserDirectory
iOS Device/private/var/mobile/Applications/
iOS Simulator/Users/Library/Application Support/iPhone Simulator/Applications/
Android/data/data/filesContext.getFilesDir

System.SysUtils.GetHomePath tiene la misma funcionalidad, pero no se recomienda cuando se está desarrollando apps multidispositivo.

IMPORTANTE:
Cuando desarrollas tu app para Android, si piensas utilizar archivos que se carguen en runtime tienes que utilizar el Deployment Manager para ponerlos en el almacenamiento interno assets\internal  o externo assets.
AddDBforAndroidAssets.png

Utiliza el siguiente código para localizar archivos en runtime:

TPath.Combine(TPath.GetDocumentsPath, 'filename')  { Interno }
TPath.Combine(TPath.GetSharedDocumentsPath, 'filename')  { Externo }
Para Android pon el Remote Path a assets\internal\
Para IOS, pon el Remote Path a StartUp\Documents


EJEMPLOS:

-Guardar un fichero a la sdcard con Android:  memo1.lines.savetofile('/sdcard/Download/test.txt'); 

-Guardarlo en la Home
 Memo.Lines.SaveToFile((TPath.GetHomePath ()  + '/test.txt');

Relacionados:
-Guardar un fichero en la carpeta Downloads: Memo1.Lines.SaveToFile(TPath.Combine(TPath.GetDownloadsPath, 'test.txt')); Memo1.Lines.LoadFromFile(TPath.Combine(TPath.GetDownloadsPath, 'test.txt'));

-Leer un documento de la carpeta Documents
System.IOUtils.TPath.GetDocumentsPath + System.SysUtils.PathDelim + 'myfile' System.IOUtils.TPath.Combine(System.IOUtils.tpath.getdocumentspath,'prueba.txt'); 

-Listar el contenido de tu device storage folder
P := '/storage/'; 
 if (FindFirst(P + '*', faAnyFile, Sr) = 0) then 
 repeat Memo1.Lines.Add(Sr.Name);
 until (FindNext(Sr) <> 0);
 FindClose(Sr); 

-Definir la ruta de una Base de datos Interbase en la carpeta Documents

uses System.IOUtils;
procedure TDataModule1.DataModuleCreate(Sender: TObject);
begin
SQLConnection1.Params.Values['Database'] := IncludeTrailingPathDelimiter(TPath.GetDocumentsPath) + ‘BASEDEDATOS.IB’;
end;


-Obtener los archivos de la carpeta assets/internal 
uses
  IOUtils;

procedure THeaderFooterForm.SpeedButton1Click(Sender: TObject);
var
  DirList: TStringDynArray;
  DirPath: string;
  s: string;
begin
  DirPath := TPath.Combine(TPath.GetDocumentsPath, 'assets');
  DirPath := TPath.Combine(DirPath, 'internal');

  // Display where we're looking for the files
  Memo1.Lines.Add('Searching ' + DirPath);

  if TDirectory.Exists(DirPath, True) then
  begin
    // Get all files. Non-Windows systems don't typically care about
    // extensions, so we just use a single '*' as a mask.
    DirList := TDirectory.GetFiles(DirPath, '*');

    // If none found, show that in memo
    if Length(DirList) = 0 then
      Memo1.Lines.Add('No files found in ' + DirPath)
    else // Files found. List them.
    begin 
      for s in DirList do
        Memo1.Lines.Add(s);
    end;
  end
  else
    Memo1.Lines.Add('Directory ' + DirPath + ' does not exist.');
end;

-Listar archivos de sistema Android en un listbox

uses System.Types, System.IOUtils, System.SysUtils;

procedure AddFiles(MyListBox: TListBox);
var
  SDA: TStringDynArray;
  I, II: Integer;
  LBI: TListBoxItem;
begin
  SDA := TDirectory.GetFiles(System.IOUtils.TPath.GetDocumentsPath + System.SysUtils.PathDelim,'*.dat');

  for I := Low(SDA) to High(SDA) do
   begin
     II := MyListBox.Items.Add(ExtractFileName(SDA[I]));
     LBI := MyListBox.ListItems[II];
     LBI.ItemData.Detail := SDA[I];
   end;

end;


-Guardar una imagen
procedure TForm1.Button1Click(Sender: TObject);
begin
  DocPathLabel.Text := TPath.GetDocumentsPath;
  Image1.Bitmap.LoadFromFile(TPath.GetDocumentsPath + PathDelim + 'imagen.jpg');
end;

-Obtener los paths del sistema


uses System.IOUtils;

procedure THeaderFooterForm.Loaded;
begin
   inherited Loaded;

   TPath.SetApplicationPath ('WhereAppTest');

   add_path (TPath.GetTempPath, 'GetTempPath');
   add_path (TPath.GetHomePath, 'GetHomePath');
   add_path (TPath.GetDocumentsPath, 'GetDocumentsPath');
   add_path (TPath.GetApplicationPath ('WhereAppTest'), 'GetApplicationPath');
   add_path (TPath.GetSharedDocumentsPath, 'GetSharedDocumentsPath');
   add_path (TPath.GetLibraryPath, 'GetLibraryPath');
   add_path (TPath.GetCachePath, 'GetCachePath');
   add_path (TPath.GetPublicPath, 'GetPublicPath');
   add_path (TPath.GetPicturesPath, 'GetPicturesPath');
   add_path (TPath.GetSharedPicturesPath, 'GetSharedPicturesPath');
   add_path (TPath.GetCameraPath, 'GetCameraPath');
   add_path (TPath.GetSharedCameraPath, 'GetSharedCameraPath');
   add_path (TPath.GetMusicPath, 'GetMusicPath');
   add_path (TPath.GetSharedMusicPath, 'GetSharedMusicPath');
   add_path (TPath.GetMoviesPath, 'GetMoviesPath');
   add_path (TPath.GetSharedMoviesPath, 'GetSharedMoviesPath');
   add_path (TPath.GetAlarmsPath, 'GetAlarmsPath');
   add_path (TPath.GetSharedAlarmsPath, 'GetSharedAlarmsPath');
   add_path (TPath.GetDownloadsPath, 'GetDownloadsPath');
   add_path (TPath.GetSharedDownloadsPath, 'GetSharedDownloadsPath');
   add_path (TPath.GetRingtonesPath.Empty, 'GetRingtonesPath');
   add_path (TPath.GetSharedRingtonesPath, 'GetSharedRingtonesPath');
   FMediaPlayer := TMediaPlayer.Create(Self);
end; // Loaded //

procedure THeaderFooterForm.add_path (path, header: string);
var
   item: TListViewItem;
   bitmap: TBitmap;
begin
   item := List_Paths.Items.Add;
   item.ButtonText := 'button';
   item.Detail := path;
   item.Text := header;
end; // add_path //


Página muy útil (recomiendo ponerla en vuestros favoritos)
Path de las funciones RTL standard en función de las distintas plataformas soportadas (Windows, OSx, Android, IOS


Más info: http://docwiki.embarcadero.com/Libraries/XE5/en/System.IOUtils.TPath.GetHomePathDelphi XE5 - deploying and accessing local files on iOS and Android

Enviar caracteres al buffer de teclado

Esta unit envía directamente caracteres al buffer de teclado, buscando en la red me encontré con que hay códigos que funcionan sólamente en versiones antiguas de Delphi, el que a continuación os copio está probado en Delphi 2009 y Rad Studio 10 y funciona perfectamente.


unit sendkey;

interface

uses
  SysUtils, Windows, Messages;

function SendKeys(SendKeysString: {$IFDEF UNICODE}PWideChar{$ELSE}PAnsiChar{$ENDIF}; Wait: Boolean): Boolean;

function AppActivate(WindowName: {$IFDEF UNICODE}PWideChar{$ELSE}PAnsiChar{$ENDIF}): Boolean;

{Buffer for working with PChar's}

const
  WorkBufLen = 40;
var
  WorkBuf : array[0..WorkBufLen] of Char;

implementation

type
  THKeys = array[0..pred(MaxLongInt)] of Byte;
var
  AllocationSize : integer;

(*
Converts a string of characters and key names to keyboard events and
passes them to Windows.

Example syntax:

SendKeys('abc123{left}{left}{left}def{end}456{left 6}ghi{end}789', True);

*)

Function SendKeys(SendKeysString: {$IFDEF UNICODE}PWideChar{$ELSE}PAnsiChar{$ENDIF}; Wait: Boolean): Boolean;
type
  WBytes = array[0..pred(SizeOf(Word))] of Byte;

  TSendKey = record
  Name : ShortString;
  VKey : Byte;
end;

const
  {Array of keys that SendKeys recognizes.

  If you add to this list, you must be sure to keep it sorted alphabetically
  by Name because a binary search routine is used to scan it.}

  MaxSendKeyRecs = 41;
  SendKeyRecs : array[1..MaxSendKeyRecs] of TSendKey =
  (
  (Name:'BKSP'; VKey:VK_BACK),
  (Name:'BS'; VKey:VK_BACK),
  (Name:'BACKSPACE'; VKey:VK_BACK),
  (Name:'BREAK'; VKey:VK_CANCEL),
  (Name:'CAPSLOCK'; VKey:VK_CAPITAL),
  (Name:'CLEAR'; VKey:VK_CLEAR),
  (Name:'DEL'; VKey:VK_DELETE),
  (Name:'DELETE'; VKey:VK_DELETE),
  (Name:'DOWN'; VKey:VK_DOWN),
  (Name:'END'; VKey:VK_END),
  (Name:'ENTER'; VKey:VK_RETURN),
  (Name:'ESC'; VKey:VK_ESCAPE),
  (Name:'ESCAPE'; VKey:VK_ESCAPE),
  (Name:'F1'; VKey:VK_F1),
  (Name:'F10'; VKey:VK_F10),
  (Name:'F11'; VKey:VK_F11),
  (Name:'F12'; VKey:VK_F12),
  (Name:'F13'; VKey:VK_F13),
  (Name:'F14'; VKey:VK_F14),
  (Name:'F15'; VKey:VK_F15),
  (Name:'F16'; VKey:VK_F16),
  (Name:'F2'; VKey:VK_F2),
  (Name:'F3'; VKey:VK_F3),
  (Name:'F4'; VKey:VK_F4),
  (Name:'F5'; VKey:VK_F5),
  (Name:'F6'; VKey:VK_F6),
  (Name:'F7'; VKey:VK_F7),
  (Name:'F8'; VKey:VK_F8),
  (Name:'F9'; VKey:VK_F9),
  (Name:'HELP'; VKey:VK_HELP),
  (Name:'HOME'; VKey:VK_HOME),
  (Name:'INS'; VKey:VK_INSERT),
  (Name:'LEFT'; VKey:VK_LEFT),
  (Name:'NUMLOCK'; VKey:VK_NUMLOCK),
  (Name:'PGDN'; VKey:VK_NEXT),
  (Name:'PGUP'; VKey:VK_PRIOR),
  (Name:'PRTSC'; VKey:VK_PRINT),
  (Name:'RIGHT'; VKey:VK_RIGHT),
  (Name:'SCROLLLOCK'; VKey:VK_SCROLL),
  (Name:'TAB'; VKey:VK_TAB),
  (Name:'UP'; VKey:VK_UP)
  );

  {Extra VK constants missing from Delphi's Windows API interface}
  VK_NULL=0;
  VK_SemiColon=186;
  VK_Equal=187;
  VK_Comma=188;
  VK_Minus=189;
  VK_Period=190;
  VK_Slash=191;
  VK_BackQuote=192;
  VK_LeftBracket=219;
  VK_BackSlash=220;
  VK_RightBracket=221;
  VK_Quote=222;
  VK_Last=VK_Quote;

  ExtendedVKeys : set of byte =
  [VK_Up,
  VK_Down,
  VK_Left,
  VK_Right,
  VK_Home,
  VK_End,
  VK_Prior, {PgUp}
  VK_Next, {PgDn}
  VK_Insert,
  VK_Delete];

const
  INVALIDKEY = $FFFF {Unsigned -1};
  VKKEYSCANSHIFTON = $01;
  VKKEYSCANCTRLON = $02;
  VKKEYSCANALTON = $04;
  UNITNAME = 'SendKeys';
var
  UsingParens,
  ShiftDown  ,
  ControlDown,
  AltDown    ,
  FoundClose : Boolean;
  PosSpace   : Byte;
  I, L       : Integer;
  NumTimes   ,
  MKey       : Word;
  KeyString  : String[20];

  procedure DisplayMessage(Message : PChar);
  begin
    MessageBox(0,Message,UNITNAME,0);
  end;

  function BitSet(BitTable, BitMask : Byte) : Boolean;
  begin
    Result := ByteBool(BitTable and BitMask);
  end;

  procedure SetBit(var BitTable : Byte; BitMask : Byte);
  begin
    BitTable := BitTable or Bitmask;
  end;

  procedure KeyboardEvent(VKey, ScanCode : Byte; Flags : Longint);
  var
    KeyboardMsg: TMsg;
  begin
    keybd_event(VKey, ScanCode, Flags,0);
    if (Wait) then
      while (PeekMessage(KeyboardMsg, 0, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)) do
      begin
        TranslateMessage(KeyboardMsg);
        DispatchMessage(KeyboardMsg);
      end;
  end;

  procedure SendKeyDown(VKey: Byte; NumTimes : Word; GenUpMsg : Boolean);
  var
    Cnt          : Word;
    ScanCode     : Byte;
    NumState     : Boolean;
    KeyBoardState: TKeyboardState;
  begin
    if (VKey=VK_NUMLOCK) then
    begin
      NumState:=ByteBool(GetKeyState(VK_NUMLOCK) and 1);
      GetKeyBoardState(KeyBoardState);
      if NumState then
        KeyBoardState[VK_NUMLOCK] := (KeyBoardState[VK_NUMLOCK] and not 1)
      else
        KeyBoardState[VK_NUMLOCK] := (KeyBoardState[VK_NUMLOCK] or 1);
      SetKeyBoardState(KeyBoardState);
      Exit;
    end;

    ScanCode:=Lo(MapVirtualKey(VKey,0));
    for Cnt := 1 to NumTimes do
      if (VKey in ExtendedVKeys)then
      begin
        KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY);
        if (GenUpMsg) then
          KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY or KEYEVENTF_KEYUP)
      end
      else
      begin
        KeyboardEvent(VKey, ScanCode, 0);
        If (GenUpMsg) then
          KeyboardEvent(VKey, ScanCode, KEYEVENTF_KEYUP);
      end;
  end;

  procedure SendKeyUp(VKey: Byte);
    var
    ScanCode: Byte;
  begin
    ScanCode := Lo(MapVirtualKey(VKey,0));
    if (VKey in ExtendedVKeys)then
      KeyboardEvent(VKey, ScanCode, KEYEVENTF_EXTENDEDKEY and KEYEVENTF_KEYUP)
    else
      KeyboardEvent(VKey, ScanCode, KEYEVENTF_KEYUP);
  end;

  procedure SendKey(MKey: Word; NumTimes : Word; GenDownMsg : Boolean);
  begin
    if (BitSet(Hi(MKey), VKKEYSCANSHIFTON)) then
      SendKeyDown(VK_SHIFT,1,False);
    if (BitSet(Hi(MKey), VKKEYSCANCTRLON)) then
      SendKeyDown(VK_CONTROL,1,False);
    if (BitSet(Hi(MKey), VKKEYSCANALTON)) then
      SendKeyDown(VK_MENU,1,False);
    SendKeyDown(Lo(MKey), NumTimes, GenDownMsg);
    if (BitSet(Hi(MKey), VKKEYSCANSHIFTON)) then
      SendKeyUp(VK_SHIFT);
    if (BitSet(Hi(MKey), VKKEYSCANCTRLON)) then
      SendKeyUp(VK_CONTROL);
    if (BitSet(Hi(MKey), VKKEYSCANALTON)) then
      SendKeyUp(VK_MENU);
  end;

{Implements a simple binary search to locate special key name strings}

  function StringToVKey(KeyString : ShortString) : Word;
  var
    Found   ,
    Collided: Boolean;
    Bottom  ,
    Top     ,
    Middle  : Byte;
  begin
    Result := INVALIDKEY;
    Bottom := 1;
    Top    := MaxSendKeyRecs;
    Found  := False;
    Middle := (Bottom+Top) div 2;
    repeat
      Collided := ((Bottom = Middle) or (Top = Middle));
      if (KeyString = SendKeyRecs[Middle].Name) then
      begin
        Found  := True;
        Result := SendKeyRecs[Middle].VKey;
      end
      else
      begin
        if (KeyString > SendKeyRecs[Middle].Name) then
          Bottom := Middle
        else
          Top  := Middle;
        Middle := (Succ(Bottom+Top)) div 2;
      end;
    until (Found or Collided);
    if (Result = INVALIDKEY) then
      DisplayMessage('Invalid Key Name');
  end;

  procedure PopUpShiftKeys;
  begin
    if (not UsingParens) then
    begin
      if ShiftDown then
        SendKeyUp(VK_SHIFT);
      if ControlDown then
        SendKeyUp(VK_CONTROL);
      if AltDown then
        SendKeyUp(VK_MENU);
      ShiftDown   := False;
      ControlDown := False;
      AltDown     := False;
    end;
  end;

begin
  AllocationSize := MaxInt;
  Result         := False;
  UsingParens    := False;
  ShiftDown      := False;
  ControlDown    := False;
  AltDown        := False;
  I              := 0;
  L              := StrLen(SendKeysString);

  if (L > AllocationSize) then
    L := AllocationSize;

  if (L = 0) then
    Exit;

  while (I < L) do
  begin
    case SendKeysString[I] of
      '(' :
      begin
        UsingParens:=True;
        Inc(I);
      end;
      ')' :
      begin
        UsingParens:=False;
        PopUpShiftKeys;
        Inc(I);
      end;
      '%' :
      begin
        AltDown:=True;
        SendKeyDown(VK_MENU, 1, False);
        Inc(I);
      end;
      '+' :
      begin
        ShiftDown:=True;
        SendKeyDown(VK_SHIFT, 1, False);
        Inc(I);
      end;
      '^' :
      begin
        ControlDown:=True;
        SendKeyDown(VK_CONTROL, 1, False);
        Inc(I);
      end;
      '{' :
      begin
        NumTimes:=1;
        if (SendKeysString[Succ(I)] = '{') then
        begin
          MKey:=VK_LEFTBRACKET;
          SetBit(Wbytes(MKey)[1], VKKEYSCANSHIFTON);
          SendKey(MKey, 1, True);
          PopUpShiftKeys;
          Inc(I, 3);
          Continue;
        end;

        KeyString := '';
        FoundClose:=False;

        while (I<=L) do
        begin
          Inc(I);
          If (SendKeysString[I]='}') then
          begin
            FoundClose:=True;
            Inc(I);
            Break;
          end;
          KeyString := KeyString + UpCase(SendKeysString[I]);
        end;

        if (Not FoundClose) then
        begin
          DisplayMessage('No Close');
          Exit;
        end;

        if (SendKeysString[I]='}') then
        begin
          MKey := VK_RIGHTBRACKET;
          SetBit(Wbytes(MKey)[1], VKKEYSCANSHIFTON);
          SendKey(MKey, 1, True);
          PopUpShiftKeys;
          Inc(I);
          Continue;
        end;

        PosSpace := Pos(' ', KeyString);

        if (PosSpace <> 0) then
        begin
          NumTimes  := StrToInt(Copy(KeyString, Succ(PosSpace), Length(KeyString)-PosSpace));
          KeyString := Copy(KeyString, 1, Pred(PosSpace));
        end;

        if (Length(KeyString) = 1) then
          MKey := VkKeyScanA(KeyString[1])
        else
          MKey := StringToVKey(KeyString);

        if (MKey <> INVALIDKEY) then
        begin
          SendKey(MKey, NumTimes, True);
          PopUpShiftKeys;
          Continue;
        end;
      end;
      '~' :
      begin
        SendKeyDown(VK_RETURN, 1, True);
        PopUpShiftKeys;
        Inc(I);
      end;
      else
      begin
        MKey:={$IFDEF UNICODE}VkKeyScanW{$ELSE}VkKeyScanA{$ENDIF}(SendKeysString[I]);
        If (MKey <> INVALIDKEY) then
        begin
          SendKey(MKey, 1, True);
          PopUpShiftKeys;
        end
        else
          DisplayMessage('Invalid KeyName');
        Inc(I);
      end;
    end;
  end;

  Result := True;
  PopUpShiftKeys;
end;

{AppActivate

This is used to set the current input focus to a given window using its
name. This is especially useful for ensuring a window is active before
sending it input messages using the SendKeys function. You can specify
a window's name in its entirety, or only portion of it, beginning from
the left.

}

var
  WindowHandle : HWND;

function EnumWindowsProc(WHandle: HWND; lParam: LPARAM): BOOL; export; stdcall;
const
  MAX_WINDOW_NAME_LEN = 80;
var
  WindowName: array[0..MAX_WINDOW_NAME_LEN] of Char;
begin
  {Can't test GetWindowText's return value since some windows don't have a title}
  GetWindowText(WHandle, WindowName, MAX_WINDOW_NAME_LEN);
  Result := (StrLIComp(WindowName, PChar(lParam), StrLen(PChar(lParam))) <> 0);
  if (not Result) then
    WindowHandle := WHandle;
end;

function AppActivate(WindowName: {$IFDEF UNICODE}PWideChar{$ELSE}PAnsiChar{$ENDIF}): Boolean;
begin
  try
    Result := True;
    WindowHandle:= {$IFDEF UNICODE}FindWindowW{$ELSE}FindWindowA{$ENDIF}(nil, WindowName);
    if (WindowHandle=0) then
      EnumWindows(@EnumWindowsProc,Integer(PChar(WindowName)));
    if (WindowHandle<>0) then
    begin
      SendMessage(WindowHandle, WM_SYSCOMMAND, SC_HOTKEY, WindowHandle);
      SendMessage(WindowHandle, WM_SYSCOMMAND, SC_RESTORE, WindowHandle);
    end
    else
      Result := False;
  except
    on Exception do
      Result := False;
  end;
end;

end.


//la llamada a la funcion podria ser:
//sendkeys('esto es una prueba',false);


Accediendo a la cámara del dispositivo Android con Rad Studio 10

Para empezar vamos a hacer una pequeña aplicación móvil en la que vamos a capturar y compartir imágenes de la cámara y de la galería de nuestro dispositivo. Nuestra aplicación va a estar escrita en código  Delphi y se ejecutará en un dispositivo Android.

Empecemos...

Iniciamos nuestro Delphi RAD Studio 10 y empezamos a crear nuestra aplicación desde File–New–Multi Device Application 
Vale la pena señalar que hay varias plantillas de diseño de aplicaciones que se pueden seleccionar, en nuestro caso elegimos una en blanco (Blank Application).


En Style seleccionaremos Android y en View= Master, el Form le llamaremos Form1. Salvamos el proyecto a través de la opción de menú  File – Save All
Vamos a incluir en nuestro proyecto un TImage, un TToolBar,  tres TButton y un TActionListAhora tenemos que cambiar algunas propiedades de los objetos en nuestro proyecto, empezando por la forma en que se mostrará en el dispositivo de visualización IDE, Los otros objetos seguirán se configurarán como sigue:

Button1
- Name= btnCam
- StyleLookup=cameratoolbutton
Button2
- Name= btnArchivo

- StyleLookup=searchtoolbutton
Button3
- Name= btnCompartir
- StyleLookup=actiontoolbutton
image1
-Name=ImgFoto
-Align=Client

Asignación de código y acciones

Con la aplicación que tiene el diseño ya definido falta sólo poner nuestras líneas de código, pero junto con este proceso vamos a asignar acciones predefinidas para poder permitir que nuestra aplicación pueda acceder a las características del dispositivo Android. 
Seleccione la btnCam y Object Inspector haga clic en la propiedad Action, a continuación, seleccione New Standard Action-Media Library-TTakePhotoFromCameraAction
Desde el Object Inspectorvaya a la pestaña Events y expanda la propiedad Action, ver más abajo:

desde allí seleccione el evento onDidFinishTaking y escriba image1.Bitmap.Assign(Image);




procedure TfrmAndPrincipal.TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap);
begin
    image1.Bitmap.Assign(Image);
end;

Con este código nuestra aplicación es capaz de capturar imágenes desde la cámara del dispositivo. 
Para el botón   btnArchivo, haremos el mismo procedimiento, usando New Standard Action-Media Library-TTakePhotoFromLibraryAction. Para este botón también se utilizará el mismo evento onDidFinishTaking y su código para btnArchivo será:




procedure TfrmAndPrincipal.TakePhotoFromLibraryAction1DidFinishTaking(Image: TBitmap);
begin   
image1.Bitmap.Assign(Image);
end;

Finalmente asignamos a  btnCompartir  desde New Standard Action - Media Library –TShowShareSheetAction y en este caso va a codificar su evento onBeforeExecute:




procedure TfrmAndPrincipal.ShowShareSheetAction1BeforeExecute(Sender: TObject);
begin
    ShowShareSheetAction1.Bitmap.Assign(image1.Bitmap);
end;

Compilar y distribuir

Terminado nuestro proceso de codificación de aplicaciones ahora vamos a compilar y desplegar nuestra aplicación. Seleccione el dispositivo de destino para nuestra aplicación, en mi caso elegí un Nexus5.
Aquí tenemos que recordar que el teléfono debe estar con el modo de depuración USB activo y la aceptación de aplicaciones de fuentes desconocidas.
Dar un Build al proyecto y ejecutar sin depurar (Run without debugging). Espere a que el propio RAD Studio 10 se encargue de instalar el APK en su dispositivo.

Como ven con sólo 3 líneas de código hemos podido crear una aplicación que capture fotos con nuestro dispositivo,  las selecciona desde la galería y las comparte, ¡¡ esto es Delphi !! ...cada día facilitándonos la vida a los programadores...

La unit quedaría así:

unit Unit1;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
  FMX.MediaLibrary.Actions, System.Actions, FMX.ActnList, FMX.StdActns,
  FMX.StdCtrls, FMX.Controls.Presentation, FMX.Objects;

type
  TForm1 = class(TForm)
    Image1: TImage;
    ToolBar1: TToolBar;
    BtnCam: TButton;
    BtnArchivo: TButton;
    BtnCompartir: TButton;
    ActionList1: TActionList;
    TakePhotoFromCameraAction1: TTakePhotoFromCameraAction;
    TakePhotoFromLibraryAction1: TTakePhotoFromLibraryAction;
    ShowShareSheetAction1: TShowShareSheetAction;
    procedure TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap);
    procedure TakePhotoFromLibraryAction1DidFinishTaking(Image: TBitmap);
    procedure ShowShareSheetAction1BeforeExecute(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.fmx}
{$R *.LgXhdpiPh.fmx ANDROID}

procedure TForm1.ShowShareSheetAction1BeforeExecute(Sender: TObject);
begin
ShowShareSheetAction1.Bitmap.Assign(image1.Bitmap);
end;

procedure TForm1.TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap);
begin
image1.Bitmap.Assign(Image);
end;

procedure TForm1.TakePhotoFromLibraryAction1DidFinishTaking(Image: TBitmap);
begin
image1.Bitmap.Assign(Image);
end;

end.