Mese: Marzo 2022

Esempio di Android PdfRendererBasic
Questo esempio mostra come visualizzare un documento PDF sullo schermo usando PdfRenderer introdotto in Android 5.0 Lollipop.

introduzione
È ora possibile eseguire il rendering di pagine di documenti PDF in immagini bitmap per la stampa utilizzando la nuova classe PdfRenderer. È necessario specificare un ParcelFileDescriptor che è ricercabile (ovvero, è possibile accedere al contenuto in modo casuale) su cui il sistema scrive il contenuto stampabile. La tua app può ottenere una pagina per il rendering con openPage(), quindi chiamare render() per trasformare PdfRenderer.Page aperto in una bitmap.

Questo esempio carica il PDF dalle risorse. Il contenuto delle risorse è compresso per impostazione predefinita e la classe PdfRenderer non può aprirlo. In questo esempio, risolviamo questo problema copiando il file nella directory della cache.

Prerequisiti
SDK Android 28
Strumenti di compilazione Android v28.0.3
Archivio di supporto Android

Codice della classe principale per il rendering :

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.android.pdfrendererbasic;

import android.app.Activity;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.ImageView;

import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.ViewModelProvider;

/**
 * This fragment has a big {@link ImageView} that shows PDF pages, and 2
 * {@link android.widget.Button}s to move between pages.
 */
public class PdfRendererBasicFragment extends Fragment {

    private PdfRendererBasicViewModel mViewModel;

    private final View.OnClickListener mOnClickListener = (view) -> {
        switch (view.getId()) {
            case R.id.previous:
                if (mViewModel != null) {
                    mViewModel.showPrevious();
                }
                break;
            case R.id.next:
                if (mViewModel != null) {
                    mViewModel.showNext();
                }
                break;
        }
    };

    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.pdf_renderer_basic_fragment, container, false);
    }

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        // View references.
        final ImageView image = view.findViewById(R.id.image);
        final Button buttonPrevious = view.findViewById(R.id.previous);
        final Button buttonNext = view.findViewById(R.id.next);

        // Bind data.
        mViewModel = new ViewModelProvider(this).get(PdfRendererBasicViewModel.class);
        final LifecycleOwner viewLifecycleOwner = getViewLifecycleOwner();
        mViewModel.getPageInfo().observe(viewLifecycleOwner, pageInfo -> {
            if (pageInfo == null) {
                return;
            }
            final Activity activity = getActivity();
            if (activity != null) {
                activity.setTitle(getString(R.string.app_name_with_index,
                        pageInfo.index + 1, pageInfo.count));
            }
        });
        mViewModel.getPageBitmap().observe(viewLifecycleOwner, image::setImageBitmap);
        mViewModel.getPreviousEnabled().observe(viewLifecycleOwner, buttonPrevious::setEnabled);
        mViewModel.getNextEnabled().observe(viewLifecycleOwner, buttonNext::setEnabled);

        // Bind events.
        buttonPrevious.setOnClickListener(mOnClickListener);
        buttonNext.setOnClickListener(mOnClickListener);
    }

}

Articolo integrale -> jarakiPdfRenderBasic

“Un Intento è un oggetto di messaggistica che puoi utilizzare per richiedere un’azione da un altro componente dell’app. Sebbene gli intenti facilitino la comunicazione tra i componenti in diversi modi, esistono tre casi d’uso fondamentali:

Avvio di un’attività
Un’attività rappresenta una singola schermata in un’app. Puoi avviare una nuova istanza di un’attività passando un intento a startActivity(). L’intento descrive l’attività da avviare e trasporta tutti i dati necessari.

Se desideri ricevere un risultato dall’attività al termine, chiama startActivityForResult(). La tua attività riceve il risultato come oggetto Intent separato nel callback onActivityResult() della tua attività. Per ulteriori informazioni, vedere la guida alle attività.

Avvio di un servizio
Un servizio è un componente che esegue operazioni in background senza un’interfaccia utente. Con Android 5.0 (livello API 21) e versioni successive, puoi avviare un servizio con JobScheduler. Per ulteriori informazioni su JobScheduler, vedere la relativa documentazione di riferimento API.

Per le versioni precedenti ad Android 5.0 (livello API 21), puoi avviare un servizio usando i metodi della classe Service. Puoi avviare un servizio per eseguire un’operazione una tantum (come il download di un file) passando un Intento a startService(). L’intento descrive il servizio da avviare e trasporta tutti i dati necessari.

Se il servizio è progettato con un’interfaccia client-server, è possibile eseguire il binding al servizio da un altro componente passando un Intent a bindService(). Per ulteriori informazioni, vedere la Guida ai servizi.

Consegnare una trasmissione
Una trasmissione è un messaggio che qualsiasi app può ricevere. Il sistema fornisce varie trasmissioni per eventi di sistema, ad esempio quando il sistema si avvia o il dispositivo inizia a caricarsi. Puoi inviare una trasmissione ad altre app passando un Intent a sendBroadcast() o sendOrderedBroadcast().”

Esempio:

public class MainActivity extends AppCompatActivity {
    public static final String EXTRA_MESSAGE = "com.example.myfirstapp.MESSAGE";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /** Called when the user taps the Send button */
    public void sendMessage(View view) {
        Intent intent = new Intent(this, DisplayMessageActivity.class);
        EditText editText = (EditText) findViewById(R.id.editTextTextPersonName);
        String message = editText.getText().toString();
        intent.putExtra(EXTRA_MESSAGE, message);
        startActivity(intent);
    }
}

Articolo integrale -> Intents

“Le basi
Per creare un servizio, devi creare una sottoclasse di Service o utilizzare una delle sue sottoclassi esistenti. Nella tua implementazione, devi sovrascrivere alcuni metodi di callback che gestiscono aspetti chiave del ciclo di vita del servizio e fornire un meccanismo che consenta ai componenti di associarsi al servizio, se appropriato. Questi sono i metodi di callback più importanti che dovresti sovrascrivere:

onStartCommand()
Il sistema richiama questo metodo chiamando startService() quando un altro componente (come un’attività) richiede l’avvio del servizio. Quando questo metodo viene eseguito, il servizio viene avviato e può essere eseguito in background a tempo indeterminato. Se lo implementi, è tua responsabilità interrompere il servizio quando il suo lavoro è completo chiamando stopSelf() o stopService(). Se si desidera fornire solo l’associazione, non è necessario implementare questo metodo.

onBind()
Il sistema richiama questo metodo chiamando bindService() quando un altro componente desidera eseguire il binding con il servizio (ad esempio per eseguire RPC). Nell’implementazione di questo metodo, devi fornire un’interfaccia che i client utilizzano per comunicare con il servizio restituendo un IBinder. Devi sempre implementare questo metodo; tuttavia, se non si desidera consentire l’associazione, è necessario restituire null.

onCreate()
Il sistema richiama questo metodo per eseguire procedure di installazione una tantum quando il servizio viene creato inizialmente (prima di chiamare onStartCommand() o onBind()). Se il servizio è già in esecuzione, questo metodo non viene chiamato.

onDestroy()
Il sistema richiama questo metodo quando il servizio non viene più utilizzato e viene distrutto. Il tuo servizio dovrebbe implementarlo per ripulire tutte le risorse come thread, listener registrati o ricevitori. Questa è l’ultima chiamata ricevuta dal servizio.”

Esempio di servizio in Android :

public class HelloService extends Service {
  private Looper serviceLooper;
  private ServiceHandler serviceHandler;

  // Handler that receives messages from the thread
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // Normally we would do some work here, like download a file.
          // For our sample, we just sleep for 5 seconds.
          try {
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              // Restore interrupt status.
              Thread.currentThread().interrupt();
          }
          // Stop the service using the startId, so that we don't stop
          // the service in the middle of handling another job
          stopSelf(msg.arg1);
      }
  }

  @Override
  public void onCreate() {
    // Start up the thread running the service. Note that we create a
    // separate thread because the service normally runs in the process's
    // main thread, which we don't want to block. We also make it
    // background priority so CPU-intensive work doesn't disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    // Get the HandlerThread's Looper and use it for our Handler
    serviceLooper = thread.getLooper();
    serviceHandler = new ServiceHandler(serviceLooper);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

      // For each start request, send a message to start a job and deliver the
      // start ID so we know which request we're stopping when we finish the job
      Message msg = serviceHandler.obtainMessage();
      msg.arg1 = startId;
      serviceHandler.sendMessage(msg);

      // If we get killed, after returning from here, restart
      return START_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
      // We don't provide binding, so return null
      return null;
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
  }
}

Articolo completo :
https://developer.android.com/guide/components/services#java

Una App android, come tutte le App ed i programmi, può accedere alle porte di comunicazione della rete a cui è connesso il dispositivo.
Le porte sono un oggetto molto importante per tutti i dispositivi connessi in rete di cui è bene avere una conoscenza minima.
Basti dire che chiunque voglia collegarsi al vostro dispositivo, anche a vostra insaputa, lo deve fare attraverso le porte (Socket).

Il flusso dei dati nelle comunicazioni attraverso web avviene solo ed esclusivamente tramite le porte attraverso il protocolli TCPIP/UDP, inizialmente ideati per scopi esclusivamente militari. Dal vostro dispositivo, (PC/TABLET/SMARTPHONE…), il flusso attraverso una porta passa per il vostro modem/router, fornito e gestito dal vostro provider internet, e via via raggiunge la destinazione. Ogni punto della rete che il vostro flusso incontra, deve fare i conti con la politica di gestione delle porte di quel punto…

Per fare un esempio, il protocollo http, (quello che utilizzate per navigare), viaggia sulla porta 80, se non diversamente specificato.

Di seguito vi fornisco il link alla documentazione della classe Android Socket :
Documentazione Classe Socket

“Un’attività fornisce la finestra in cui l’app disegna la sua interfaccia utente. Questa finestra in genere riempie lo schermo, ma può essere più piccola dello schermo e fluttuare sopra altre finestre. In genere, un’attività implementa una schermata in un’app. Ad esempio, una delle attività di un’app può implementare una schermata Preferenze, mentre un’altra attività implementa una schermata Seleziona foto.

La maggior parte delle app contiene più schermi, il che significa che comprendono più attività. In genere, un’attività in un’app viene specificata come attività principale, ovvero la prima schermata visualizzata quando l’utente avvia l’app. Ogni attività può quindi avviare un’altra attività per eseguire azioni diverse. Ad esempio, l’attività principale in una semplice app di posta elettronica può fornire la schermata che mostra una casella di posta in arrivo. Da lì, l’attività principale potrebbe avviare altre attività che forniscono schermate per attività come la scrittura di e-mail e l’apertura di singole e-mail.

Sebbene le attività lavorino insieme per formare un’esperienza utente coesa in un’app, ogni attività è solo vagamente legata alle altre attività; in genere ci sono dipendenze minime tra le attività in un’app. In effetti, le attività spesso avviano attività appartenenti ad altre app. Ad esempio, un’app browser potrebbe avviare l’attività Condividi di un’app di social media.

Per utilizzare le attività nella tua app, devi registrare le informazioni su di esse nel manifest dell’app e devi gestire i cicli di vita delle attività in modo appropriato. Il resto di questo documento introduce questi argomenti.”

from developer.android.com, articolo completo : Activities
per iniziare : Android Documentation