Analitcs

Pesquisar no conteúdo do blog.atlabs.com.br

terça-feira, 14 de outubro de 2014

GERAL - Recuperando Senhas dos Navegadores.

Reações: 
Retirado de:

http://www.techtudo.com.br/dicas-e-tutoriais/noticia/2014/10/esqueceu-uma-senha-saiba-como-recuperar-no-historico-do-seu-navegador.html



Esqueceu uma senha? Saiba como recuperar no histórico do seu navegador

Helito Bijora
por 
Para o TechTudo

Os principais navegadores do mercado contam com o recurso de memorizar logins e senhas. Além de facilitar o acesso às redes sociais e e-mails, o recurso pode ajudar o usuário a recuperar senhas esquecidas sem precisar recorrer ao site. Se você usa o recurso e esqueceu uma senha, saiba como usá-lo para descobrir uma senha salva no Google Chrome , Mozilla Firefox, Internet Explorer e Safari.
Logins e senhas de redes sociais são roubados e armazenados em botnet; entenda o caso (Foto: Pond5)Veja como recuperar senhas perdidas no próprio navegador (Foto: Pond5)
Chrome
Passo 1. Acesse o menu do navegador e clique em “Configurações”;
Acesse as configurações do Chrome (Foto: Reprodução/Helito Bijora) Acesse as configurações do Chrome (Foto: Reprodução/Helito Bijora)
Passo 2. Role a página de configurações até o fim e clique em “Mostrar configurações avançadas…”;
Abra as configurações avançadas (Foto: Reprodução/Helito Bijora) Abra as configurações avançadas (Foto: Reprodução/Helito Bijora)
Passo 3. Localize o item “Senhas e formulários” e clique em “Gerenciar senhas”;
Gerenciando senhas salvas no Chrome (Foto: Reprodução/Helito Bijora) Gerenciando senhas salvas no Chrome (Foto: Reprodução/Helito Bijora)
Passo 4. Em seguida, use a busca para localizar o site que deseja recuperar a senha. Por fim, clique sobre ele e, ao lado da senha, clique em “Mostrar”. Será necessário digitar a senha de administrador do sistema, no caso do computador, para revelar a senha.
Gerenciando senhas salvas no Chrome (Foto: Reprodução/Helito Bijora) Gerenciando senhas salvas no Chrome (Foto: Reprodução/Helito Bijora)
Firefox
Passo 5. Acesse o menu do Firefox e clique em “Opções”;
Acesse as opções do Firefox (Foto: Reprodução/Helito Bijora) Acesse as opções do Firefox (Foto: Reprodução/Helito Bijora)
Passo 6. Na janela de configurações do navegador, acesse a aba “Segurança” e clique em “Senhas memorizadas…”;
Gerenciando senhas salvas no Firefox (Foto: Reprodução/Helito Bijora) Gerenciando senhas salvas no Firefox (Foto: Reprodução/Helito Bijora)
Passo 7. Por fim, clique em “Exibir senhas” e confirme. Use a busca para facilitar a localização da senha desejada.
Revelando senha salva pelo navegador (Foto: Reprodução/Helito Bijora) Revelando senha salva pelo navegador (Foto: Reprodução/Helito Bijora)
Internet Explorer
Passo 8. Abra o “Painel de Controle” e clique em “Contas Usuário e Proteção p/ Família”;
Acesse o Painel de Controle do Windows (Foto: Reprodução/Helito Bijora) Acesse o Painel de Controle do Windows (Foto: Reprodução/Helito Bijora)
Passo 9. Em seguida, clique em “Gerenciador de Credenciais”;
Acesse as credenciais do Internet Explorer (Foto: Reprodução/Helito Bijora) Acesse as credenciais do Internet Explorer (Foto: Reprodução/Helito Bijora)
Passo 10. Por fim, localize o site desejado, clique sobre a seta à direita e clique em “Mostrar”, ao lado de “Senha”. Você precisará digitar a senha de administrador do sistema para revelar a senha.
Descobrindo senha salva pelo Internet Explorer (Foto: Reprodução/Helito Bijora) Descobrindo senha salva pelo Internet Explorer (Foto: Reprodução/Helito Bijora)
Safari
Passo 11. Acesse o menu “Safari” e clique em “Preferências…”;
Abra as configurações do Safari (Foto: Reprodução/Helito Bijora) Abra as configurações do Safari (Foto: Reprodução/Helito Bijora)
Passo 12. Nas preferências do navegador, abra a aba “Senhas” e marque a opção “Mostrar senhas para sites selecionados”, no canto inferior esquerdo da janela. Por segurança, será necessário confirmar a senha de administrador do sistema.
Visualizando senha salva no Safari (Foto: Reprodução/Helito Bijora) Visualizando senha salva no Safari (Foto: Reprodução/Helito Bijora)
Pronto. Com essas dicas, você conseguirá recuperar sua senha facilmente e sem precisar trocá-la.

quinta-feira, 9 de outubro de 2014

DELPHI / ANDROID (Firemonkey) - Verificar existência de câmera frontal e traseira - Check if there is front and back camera

Reações: 
No Android não temos uma função para verificar se o aparelho contém câmera frontal e/ou traseira, porém podemos fazer essa verificação com uma simples função Try/Except.

Para isso precisamos adicionar um TCameraComponent e criar a função passando o TCameraKind como parâmetro.

Veja a função abaixo:

 

function TFrmPrincipal.HasCamera(AKind : TCameraKind): Boolean;
begin
  Result := False;
  Try
    CameraComponent.Active := false;
    CameraComponent.Kind   := AKind;
    CameraComponent.Active := true;
    Result := True;
  Except
    Result := False;
  End;
end;



E podemos usar essa função em um evento dessa forma:

 
procedure TFrmPrincipal.Button1Click(Sender: TObject);
begin
  if HasCamera(TCameraKind.ckFrontCamera) then
    //Existe câmera frontal
  else
    //Não existe câmera frontal

  if HasCamera(TCameraKind.ckBackCamera) then
    //Existe câmera traseira
  else
    //Não existe câmera traseira

end;

quarta-feira, 8 de outubro de 2014

DELPHI - Criando um emulador Android

Reações: 

Retirado do site:

 http://docwiki.embarcadero.com/RADStudio/XE6/en/Creating_an_Android_Emulator

Criando um emulador Android


Um emulador Android é um dispositivo virtual Android (AVD) que representa um dispositivo Android específica. Você pode usar um emulador Android como uma plataforma de destino para executar e testar os aplicativos Android em seu PC.
YellowBang.pngAtenção: emuladores Android são extremamente lento . e não suportam o mesmo conjunto de recursos como dispositivos reais 
Nós não recomendamos que você tente usar um emulador Android:

Conteúdo

 [ hide 

Requisitos Mínimos para um emulador Android

Para criar um emulador Android (disponibilizada pelo Google como parte do SDK do Android), recomendamos a utilização de, pelo menos, o seguinte:
Nós não recomendamos o uso de um emulador do Android em uma máquina virtual (VM), porque o suporte GPU para o emulador não está geralmente disponível em VMs. No entanto, se você estiver executando o Delphi em uma máquina virtual em um computador Mac OS X, você pode considerar o uso de um emulador remoto no Mac, uma vez que o emulador não funciona em VMs. Para mais informações, consultehttp://delphi.org/2013/09/debugging-contra-a-remote-android-emulator/ .
RAD Studio suporta o emulador para versões do Android 4.x . 
Nós não apoiamos emuladores para a versão 2.x (Gingerbread) porque emuladores para Android alvo versões 2.x uma CPU ARMv6, que Delphi não suporta.

Emuladores do Android exigem uma GPU separada

Emuladores Android são fortemente dependentes de hardware, e isso inclui o hardware a ser emulado, bem como o hardware em que o emulador funciona.
Por este motivo, recomendamos que você verificar a presença de uma placa gráfica apropriada em seu sistema de desenvolvimento.
  1. Abra Painel de Controle \ Aparência e Personalização \ Display \ Resolução de Tela .
  2. Clique em Configurações Avançadas .
  3. Dê uma olhada nas propriedades exibidas de sua placa gráfica.
    • Se você não tem uma GPU adequada, provavelmente não vale a pena o seu tempo para criar e tentar executar um emulador Android. Encontrar um outro sistema de desenvolvimento que tem uma GPU adequada.
    • Nós não recomendamos Intel GPUs.
    • Se você receber mensagens de erro sobre OpenGL ES ao tentar executar o emulador Android, isso significa que sua GPU provavelmente não é adequado.

Criando um emulador Android é opcional

Se você decidir criar o seu próprio emulador Android, considere criar um emulador para cada dispositivo Android que você deseja oferecer suporte. Tenha em mente que emuladores Android muitas vezes correr tão lento que algumas pessoas consideram os inutilizáveis.
RAD Studio suporta as seguintes metas:
  • Emuladores Android que são versão 4.0 ou mais recente
  • Dispositivos Android que são ARM versão 7 ou mais recente
Emuladores Android não pode ser executado em uma máquina virtual (VM). Apesar de um emulador pode ser executado em uma máquina virtual, o emulador não vai realmente executar um aplicativo.
Nota: É um problema de desempenho bem conhecido que emuladores Android são extremamente lentos.

Instalação de uma imagem do sistema Android (Obrigatório)

Antes de criar um emulador Android, você precisa instalar uma imagem do sistema Android que seus emuladores pode usar.
Nota: Se você instalou o Android SDK e NDK durante a instalação do RAD Studio, uma imagem do sistema Android válido (como Android 4.2.2 API 17 ) já deve ser mostrado como instalado no Gerenciador de SDK Android . Neste caso, você não precisa instalar outra imagem do sistema Android.
Siga estes passos:
  1. Inicie o Gerenciador de dispositivos Android Virtual (selecione Iniciar> Todos os Programas> Embarcadero RAD Studio XE6> SDKs Android> Gerenciador Android AVD ).
  2. Na árvore de pacotes, localizar e verificar a ARM EABI V7A Sistema Imagem nó no primeiro nó Android na lista.
    Por exemplo: 4.2.2 Android (API 17) ou Android 4.3 (API 18)
    InstallAndroidSystemImage.png
  3. Clique em Instalar um pacote . (Apague todas as caixas de seleção que foram selecionados auto-.)
  4. Na Escolha pacotes para instalar página, clique em Aceitar licença e clique em Instalar para instalar a imagem do sistema.

Criando um Android Emulator - Campos-chave

Criando um emulador Android Usando o Android Virtual Device Manager

Para criar um emulador do Android em seu sistema, siga estes passos:
  1. Inicie o Gerenciador de SDK Android (selecione Iniciar> Todos os Programas> Embarcadero RAD Studio XE6> SDKs Android> Gerenciador Android AVD ).

    AllProgsAndrVDMgr2.png
  2. No Android Virtual Device Manager , clique no Novo botão para criar um novo dispositivo virtual.
    Clique em Novo no Gerenciador de Android AVD
  3. No Criar novo dispositivo virtual Android (AVD) caixa de diálogo, selecione um dispositivo Android para emular, e digite os detalhes que descrevem o dispositivo Android que você deseja emular. A fim de executar um aplicativo móvel FireMonkey , seu emulador Android deve atender aos seguintes requisitos:
    1. No Alvo , selecione um SDK Android com um nível API que é de 17 ou superior. A lista drop-down contém as versões instaladas do Android SDK.
    2. Sob Opções de emulação , verifique Use GPU anfitrião .
    3. Em Dispositivo , selecione o dispositivo Android para emular.
    Dica: Emulando um dispositivo Android mais antigo como o Nexus S pode ser mais rápido do que a emulação de um dispositivo mais novo, maior, como o Nexus 10.
  4. Clique em OK duas vezes para criar o seu novo emulador Android.
  5. Você pode agora ver o seu emulador no Android Virtual Device Manager.
    AVDwithEmulator.png
RAD Studio lista os emuladores Android no Project Manager , dentro do alvo nó do Android nó plataforma de destino. Veja Usando o alvo Node .
Nota: Como referência, aqui estão os locais padrão instalada do Android Development Tools instalado pelo instalador RAD Studio:
  • Se você precisa para iniciar o Gerenciador de SDK Android diretamente, aqui é a sua localização:
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 14.0 \ PlatformSDKs \ adt-bundle-windows-x86-20131030
  • Se SDK Manager.exe não iniciar, use Android.bat , que está localizado aqui:
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 14.0 \ \ PlatformSDKs ADT-bundle-windows-x86-20131030 \ sdk

Criando um emulador Android usando a linha de comando

Você pode criar um emulador Android na janela de comando, digitando um comando como este:
echo não |-s android criar avd-n my_android -t 1
Para a pele, você pode querer adicionar essa opção:
--skin WXGA800-7in
Para mais informações, consulte a documentação do Android .

Começar um emulador Android

Quando o emulador é a plataforma de destino atual, você não tem que iniciar o emulador antes de executar seu aplicativo Android no emulador. No entanto, recomendamos que você iniciar o seu emulador Android separadamente, talvez antes de começar a RAD Studio. Emuladores são notoriamente lento para iniciar e executar, assim que começar o emulador de antemão significa que o aplicativo pode obter para o emulador mais rapidamente.
A maneira recomendada para iniciar um emulador Android é usando o Gerenciador de dispositivos Android Virtual , que pode ser iniciado a partir do Gerenciador de SDK Android .
Para iniciar um emulador do Android, como o emulador padrão instalado no RAD Studio:
  1. Inicie o Gerenciador de dispositivos Android Virtual (selecione Iniciar> Todos os Programas> Embarcadero RAD Studio XE6> SDKs Android> Gerenciador Android AVD ).
  2. Selecione o emulador e clique em Iniciar .
    RSXE5Android.png
  3. Em seguida, clique lançamento na caixa de diálogo Opções de inicialização.
    LaunchOptions2.png
  4. O emulador deve agora começar (isso pode levar cinco ou dez minutos):
    EmulatorRunning3.png
    No Project Manager, o seu emulador deve aparecer no Alvo nó da plataforma de destino Android, com o seu porto designado (como (5554) ):
    OurEmulatorRunning.png
Dica: Se o gerente de projeto não mostrar o seu emulador rodando Android quanto correr, com o mesmo ícone como na imagem acima, consulte Usando o nó alvo .
Seu próximo passo é executar um aplicativo Android no seu emulador . No Project Manager, verifique se o nome do emulador é em negrito eo número da porta é indicado entre parênteses (como (5554) ), indicando que o emulador está em execução e é a atual plataforma de destino selecionada.

Consulte também


segunda-feira, 6 de outubro de 2014

DELPHI / C++ (Firemonkey) - Tirando fotos e compartilhando - Taking photo and sharing

Reações: 

Retirado do site:

http://docwiki.embarcadero.com/RADStudio/XE6/en/Mobile_Tutorial:_Taking_and_Sharing_a_Picture,_and_Sharing_Text_%28iOS_and_Android%29


Mobile Tutorial: Taking and Sharing a Picture, and Sharing Text (iOS and Android)

Go Up to Mobile Tutorials: Mobile Application Development (iOS and Android)


Contents

 [hide
Before starting this tutorial, you should read and perform the following tutorial:
This tutorial covers the following typical tasks for using pictures and sharing text in your mobile applications.
On iOS Devices:
Taking a picture with the device camera Using a picture from the device Photo Library
TakePhotoFromCameraAction.PNG TakePhotoFromLibraryAction.PNG


Sharing or printing a picture Sharing text
ShowShareSheetAction.PNG ShowShareSheetActioniOS7.PNG

On Android Devices:
Taking a picture with the device camera Using a picture from the device Photo Library
Android TakeCameraPicture.png Android SelectfromLibrary.png


Sharing or printing a picture Sharing text
Android SendImage.png ShowShareSheetActionAndroid.png


This functionality is provided as Actions, and you need to write only one line of code for each task.
An action corresponds to one or more elements of the user interface, such as menu commands, toolbar buttons, and controls.
Actions serve two purposes:
  • An action can represent properties common to the user interface elements—such as whether a control is enabled or whether a check box is selected.
  • An action can respond when a control fires—such as when the user clicks a button or chooses a menu item.
In this tutorial, you learn how to assign actions to user interface elements (such as a button) for each functionality that you want to support.

Building the User Interface for the Application

The user interface of this sample application is quite simple, as shown in the following picture:
CameraAppUIElements.png


Place the following components on the Form Designer:
  • TToolBar component
    • On the toolbar, put three TButton components. Each button uses different icons.
    • Set the StyleLookup property for the three buttons to cameratoolbuttonbordered, searchtoolbuttonbordered, and actiontoolbuttonbordered, respectively.
  • TImage component
    • Set the Align property to Client.
  • TActionList component

Taking a Picture with a Mobile Device Camera

You can define an action to take a photo using the camera on your mobile device. Perform the following steps:
  1. On the Form Designer, select the button (for taking a photo).
  2. In the Object Inspector, select the drop-down list for the Action property.
  3. Select New Standard Action | Media Library | TTakePhotoFromCameraAction:

    CreateTakePhotoFromCameraAction.png

  4. On the Events tab, expand the Action node, and then double-click the OnDidFinishTaking event.
    TakePhotoFromCameraAction1DidFinishTaking.png

  5. Add the following code to the OnDidFinishTaking event handler:
Delphi:
procedure TForm1.TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap);
begin
  Image1.Bitmap.Assign(Image);
end;
C++Builder:

void __fastcall TForm2::TakePhotoFromCameraAction1DidFinishTaking(TBitmap *Image)
{
    Image1->Bitmap->Assign(Image);
}
This code assigns a picture taken from the mobile device camera to the Bitmap property of the TImage component.

Using a Picture from the Mobile Device Photo Library

You can define an action to use a photo from the Photo Library with the following steps:
  1. On the Form Designer, choose the button that you want to use (for picking up a photo).
  2. In the Object Inspector, click the drop-down list for the Action property and select New Standard Action | Media Library | TTakePhotoFromLibraryAction.
  3. In the Events tab, expand the Action node, and then double-click the OnDidFinishTaking event.
  4. Add the following code to the OnDidFinishTaking event handler:
Delphi:
procedure TForm1.TakePhotoFromLibraryAction1DidFinishTaking(Image: TBitmap);
begin
  Image1.Bitmap.Assign(Image);
end;
C++Builder:
void __fastcall TForm2::TakePhotoFromLibraryAction1DidFinishTaking(TBitmap *Image)
{
   Image1->Bitmap->Assign(Image);
}
The code above assigns a picture taken from the Photo Library to the Bitmap property of the TImage component.

Sharing or Printing a Picture

From your mobile application, you can share a photo on social networking sites (such as Facebook and Twitter), you can send the picture to a printer, use the picture as an attachment to e-mail, assign it to Contacts, and so on.

ShowShareSheetAction.PNG

This multi-share service is called Share Sheet Functionality, and you can implement this functionality using the following steps:
  1. On the Form Designer, select the button (for sharing a photo).
  2. In the Object Inspector, click the drop-down list for the Action property, and select New Standard Action | Media Library | TShowShareSheetAction.
  3. On the Events tab, expand the Action node, and then double-click the OnBeforeExecute event.
  4. Add the following code to the OnBeforeExecute event handler:
Delphi:
procedure TForm1.ShowShareSheetAction1BeforeExecute(Sender: TObject);
begin
  ShowShareSheetAction1.Bitmap.Assign(Image1.Bitmap);
end;
C++Builder:
void __fastcall TForm2::ShowShareSheetAction1BeforeExecute(TObject *Sender)
{
    ShowShareSheetAction1->Bitmap->Assign(Image1->Bitmap);
}
The code above assigns a picture on the TImage component to "Share Sheet Functionality".
After you select Facebook from the list of services, you can post the picture on Facebook with your comment:
IOSCamera.PNG
Note: In this subsection, screenshots of iOS devices are used as an example.
For a sample application that uses share sheet functionality, see the FMX.Mobile.PhotoEditorDemo Sample (Delphi).

Sharing Text

From your mobile application, you can share text using the mobile device's share sheet. The applications that appear in the share sheet depend on the device:
  • On an iOS device, a list of suitable sharing options is shown depending on the content that your app wants to share, but there is not a full app-sharing mechanism.
  • On an Android device, the choices are dependent on sharing options and installed apps.
From your mobile application, you can share text on social networking sites (such as Facebook and Twitter), you can send it by email, SMS (Short Message Service), and other available methods.
You can implement this functionality with the multi-share service called Share Sheet Functionality. The TShowShareSheetAction is the standard action for sharing images and text. TShowShareSheetAction shows the available sharing options depending on the type of content you are sharing. That is, the options shown for Text are different than for a Bitmap.
This example shows a simple implementation of this functionality. We share the text that the user has typed into a Memo.
  1. Create a FireMonkey mobile application.
  2. Place the following components on the Form Designer:
    • TToolBar component
      • On the toolbar, add a TButton component.
      • Set the StyleLookup property for the button as follows:
        • actiontoolbuttonbordered or actiontoolbutton for iOS
        • actiontoolbutton for Android
    Note: The actiontoolbuttonbordered property includes the button with a border, while actiontoolbutton shows the button without a border.
After you have added the components to the sample application:
  1. On the Form Designer, select the button (for sharing the text).
  2. In the Object Inspector, click the drop-down list for the Action property, and select New Standard Action | Media Library | TShowShareSheetAction.
    TShowShareSheetOption.png
  3. On the Events tab, expand the Action node, and then double-click the OnBeforeExecute event.
  4. Add the following code to the OnBeforeExecute event handler:
Delphi:
procedure TDemonstration.ShowShareSheetAction1BeforeExecute(Sender: TObject);
begin
    ShowShareSheetAction1.TextMessage:= Memo1.Lines.Text;   
end;
C++Builder:
void __fastcall TDemonstration::ShowShareSheetAction1BeforeExecute(TObject *Sender)
{
 ShowShareSheetAction1->TextMessage = Memo1->Lines->Text;
}
ShowShareSheetActioncode.png
The code above uses the TextMessage property to assign the text to be shared, as previously typed in a TMemo.

See Also

Max Gehringer