PDF rendering in Android

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

Interazione tra Attività ed Apps in Android

“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

Servizi in Android

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

Socket in Android

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

Concetto di Attività in Android

“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

Semplice Sinth MIDI

MidiSinthDeviceService.java

/*
 * Copyright (C) 2015 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.midisynth;

import android.media.midi.MidiDeviceService;
import android.media.midi.MidiDeviceStatus;
import android.media.midi.MidiReceiver;

import com.example.android.common.midi.synth.SynthEngine;

public class MidiSynthDeviceService extends MidiDeviceService {

    private SynthEngine mSynthEngine = new SynthEngine();
    private boolean mSynthStarted = false;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        mSynthEngine.stop();
        super.onDestroy();
    }

    @Override
    public MidiReceiver[] onGetInputPortReceivers() {
        return new MidiReceiver[]{mSynthEngine};
    }

    /**
     * This will get called when clients connect or disconnect.
     */
    @Override
    public void onDeviceStatusChanged(MidiDeviceStatus status) {
        if (status.isInputPortOpen(0) && !mSynthStarted) {
            mSynthEngine.start();
            mSynthStarted = true;
        } else if (!status.isInputPortOpen(0) && mSynthStarted) {
            mSynthEngine.stop();
            mSynthStarted = false;
        }
    }

}

MainActivity.java

/*
 * Copyright (C) 2015 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.midisynth;

import android.content.pm.PackageManager;
import android.media.midi.MidiDevice.MidiConnection;
import android.media.midi.MidiDeviceInfo;
import android.media.midi.MidiManager;
import android.os.Bundle;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.Menu;
import android.view.MenuItem;
import android.view.WindowManager;
import android.widget.Toast;

import com.example.android.common.midi.MidiOutputPortConnectionSelector;
import com.example.android.common.midi.MidiPortConnector;
import com.example.android.common.midi.MidiTools;

/**
 * Simple synthesizer as a MIDI Device.
 */
public class MainActivity extends AppCompatActivity {

    private MidiOutputPortConnectionSelector mPortSelector;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
        ActionBar actionBar = getSupportActionBar();
        if (actionBar != null) {
            actionBar.setDisplayShowTitleEnabled(false);
        }

        if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_MIDI)) {
            setupMidi();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        setKeepScreenOn(menu.findItem(R.id.action_keep_screen_on).isChecked());
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.action_keep_screen_on:
                boolean checked = !item.isChecked();
                setKeepScreenOn(checked);
                item.setChecked(checked);
                break;
        }
        return super.onOptionsItemSelected(item);
    }

    private void setKeepScreenOn(boolean keepScreenOn) {
        if (keepScreenOn) {
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        } else {
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        }
    }

    private void setupMidi() {
        // Setup MIDI
        MidiManager midiManager = (MidiManager) getSystemService(MIDI_SERVICE);

        MidiDeviceInfo synthInfo = MidiTools.findDevice(midiManager, "AndroidTest",
                "SynthExample");
        int portIndex = 0;
        mPortSelector = new MidiOutputPortConnectionSelector(midiManager, this,
                R.id.spinner_synth_sender, synthInfo, portIndex);
        mPortSelector.setConnectedListener(new MyPortsConnectedListener());
    }

    private void closeSynthResources() {
        if (mPortSelector != null) {
            mPortSelector.close();
        }
    }

    // TODO A better way would be to listen to the synth server
    // for open/close events and then disable/enable the spinner.
    private class MyPortsConnectedListener
            implements MidiPortConnector.OnPortsConnectedListener {
        @Override
        public void onPortsConnected(final MidiConnection connection) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (connection == null) {
                        Toast.makeText(MainActivity.this,
                                R.string.error_port_busy, Toast.LENGTH_SHORT)
                                .show();
                        mPortSelector.clearSelection();
                    } else {
                        Toast.makeText(MainActivity.this,
                                R.string.port_open_ok, Toast.LENGTH_SHORT)
                                .show();
                    }
                }
            });
        }
    }

    @Override
    public void onDestroy() {
        closeSynthResources();
        super.onDestroy();
    }

}

A minimal App in Android

In questo post vi mostro la struttura minimale di una App Android. In realtà potrebbe essere resa ancora più semplice, ma non chiarirebbe bene quali sono le parti che costituiscono l’App.

Iniziamo con il file AndroidManifest.xml (directory app/manifests) :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.andreabianchini.simpleandroidapp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.SimpleAndroidApp">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Passiamo al file che contiene il programma principale dell’App, MainActivity.java (directory app/java) :

package com.andreabianchini.simpleandroidapp;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Al programma (Activity) principale sopra riportato viene associato un file di risorse, activity_main.xml, (directory app/res/layout), che serve a definire l’aspetto ed i contenuti grafici della schermata associata all’attività principale :

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

In questo caso la nostra App Android minimale visualizzerà una schermata con la scritta : ‘Hello World!’.

Con l’ambiente di sviluppo ‘Android Studio’ potete generare automaticamente questa applicazione in un minuto.

Ecco il risultato:

App Android minimale

Catch the note

In questo articolo rendo pubblico, a titolo di esempio, il codice java principale della mia app CatchTheNote, disponibile in versione completa alla voce di menù Android.

package com.andreabianchini.catchthenote;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.media.AudioManager;
import android.media.SoundPool;
import android.os.Bundle;
import android.os.Handler;
import android.text.InputFilter;
import android.text.Spanned;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

import com.google.android.gms.ads.AdRequest;
import com.google.android.gms.ads.AdView;
import com.google.android.gms.ads.MobileAds;

import java.util.Random;

public class MainActivity extends AppCompatActivity {
    private SoundPool soundPool;
    private int soundID,tone;
    private int a,as,b,c,cs,d,ds,e,f,fs,g,gs;
    boolean plays = false, loaded = false;
    float actVolume, maxVolume, volume;
    AudioManager audioManager;
    int counter;
    int [] notes=new int[8];
    int [] notesId=new int[8];
    int nnotes=1;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // AudioManager audio settings for adjusting the volume
        audioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
        actVolume = (float) audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
        maxVolume = (float) audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
        volume = actVolume / maxVolume;

        //Hardware buttons setting to adjust the media sound
        this.setVolumeControlStream(AudioManager.STREAM_MUSIC);

        // the counter will help us recognize the stream id of the sound played  now
        counter = 0;

        // Load the sounds
        soundPool = new SoundPool(10, AudioManager.STREAM_MUSIC, 0);
        soundPool.setOnLoadCompleteListener(new SoundPool.OnLoadCompleteListener() {
            @Override
            public void onLoadComplete(SoundPool soundPool, int sampleId, int status) {
                loaded = true;
                plays=false;
            }
        });

        a = soundPool.load(this, R.raw.a, 1);
        as = soundPool.load(this, R.raw.as, 1);
        b = soundPool.load(this, R.raw.b, 1);
        c = soundPool.load(this, R.raw.c, 1);
        cs = soundPool.load(this, R.raw.cs, 1);
        d = soundPool.load(this, R.raw.d, 1);
        ds = soundPool.load(this, R.raw.ds, 1);
        e = soundPool.load(this, R.raw.e, 1);
        f = soundPool.load(this, R.raw.f, 1);
        fs = soundPool.load(this, R.raw.fs, 1);
        g = soundPool.load(this, R.raw.g, 1);
        gs = soundPool.load(this, R.raw.gs, 1);

        soundID = a;
        nnotes=1;
        notes[0]=0;
        notesId[0]=a;

        Button button =  findViewById(R.id.btPlay);
        Button button1 =  findViewById(R.id.btA);
        Button btChange =  findViewById(R.id.btChange);
        Button btShow =  findViewById(R.id.btShow);
        Button btInfo =  findViewById(R.id.btInfo);
        EditText etNNotes = findViewById(R.id.etNNotes);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                playSound(v);
           }
        });

        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                playA(v);
            }
        });

        btChange.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                changeNote(v);
            }
        });

        btShow.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showNote(v);
            }
        });

        btInfo.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showInfo(v);
            }
        });

        etNNotes.setFilters(new InputFilter[]{ new InputFilterMinMax("1", "8")});

        // Initialize the Mobile Ads SDK
        MobileAds.initialize(this, getString(R.string.admob_app_id));

        AdView mBannerAd;

        mBannerAd = findViewById(R.id.adView);

        AdRequest adRequest = new AdRequest.Builder()
                .build();
        mBannerAd.loadAd(adRequest);

    }

    public void showInfo(View v) {
        Intent intent = new Intent(MainActivity.this, Info.class);
        startActivity(intent);

    }

    public void showNote(View v) {
        TextView tv  =  findViewById(R.id.tvNote);
        EditText etNNotes = findViewById(R.id.etNNotes);
        nnotes = Integer.parseInt(etNNotes.getText().toString());
        String s;
        s="";
        for(int i=0;i<nnotes;i++) {
            switch (notes[i]) {
                case 0:
                    s+="A ";
                    break;
                case 1:
                    s+="A# ";
                    break;
                case 2:
                    s+="B ";
                    break;
                case 3:
                    s+="C ";
                    break;
                case 4:
                    s+="C# ";
                    break;
                case 5:
                    s+="D ";
                    break;
                case 6:
                    s+="D# ";
                    break;
                case 7:
                    s+="E ";
                    break;
                case 8:
                    s+="F ";
                    break;
                case 9:
                    s+="F# ";
                    break;
                case 10:
                    s+="G ";
                    break;
                case 11:
                    s+="G# ";
                    break;

            }
        }
        tv.setText(s);
    }

    public void changeNote(View v) {
        EditText etNNotes = findViewById(R.id.etNNotes);
        nnotes = Integer.parseInt(etNNotes.getText().toString());
        int last,last1;
        last1=2;
        last=1;
        for(int i=0;i<nnotes;i++) {
            tone=0;
            if (i>1)
            while(tone==last || (Math.abs(tone-last)==1 && Math.abs(last1-last)==1) || (Math.abs(tone-last)==3 && Math.abs(last1-last)==3) || (Math.abs(tone-last)==2 && Math.abs(last1-last)==3) || (Math.abs(tone-last)==3 && Math.abs(last1-last)==2)) {
                tone = new Random().nextInt(12);
            }
            else
                tone = new Random().nextInt(12);
            last1 = last;
            last = tone;
            notes[i]=tone;
            switch (tone) {
                case 0:
                    soundID = a;
                    break;
                case 1:
                    soundID = as;
                    break;
                case 2:
                    soundID = b;
                    break;
                case 3:
                    soundID = c;
                    break;
                case 4:
                    soundID = cs;
                    break;
                case 5:
                    soundID = d;
                    break;
                case 6:
                    soundID = ds;
                    break;
                case 7:
                    soundID = e;
                    break;
                case 8:
                    soundID = f;
                    break;
                case 9:
                    soundID = fs;
                    break;
                case 10:
                    soundID = g;
                    break;
                case 11:
                    soundID = gs;
                    break;

            }
            notesId[i]=soundID;
        }
    }

    public void playSound(View v) {
        // Is the sound loaded does it already play?
        TextView tv  =  findViewById(R.id.tvNote);
        tv.setText(getString(R.string.note));

        for (int i=0;i<nnotes;i++){
        if (loaded && !plays) {
            soundPool.play(notesId[i], 1, 1, 0, 0, 1);
            counter = counter++;
            //Toast.makeText(this, "Played sound", Toast.LENGTH_SHORT).show();
            //plays = true;
        }
            try { Thread.sleep(1600); }
            catch (InterruptedException ex) { android.util.Log.d("Catch the Note", ex.toString()); }        }
    }

    public void playA(View v) {
        // Is the sound loaded does it already play?
        TextView tv  =  findViewById(R.id.tvNote);
        tv.setText(getString(R.string.note));

            if (loaded && !plays) {
                soundPool.play(a, 1, 1, 0, 0, 1);
                counter = counter++;
                //Toast.makeText(this, "Played sound", Toast.LENGTH_SHORT).show();
                //plays = true;
            }
            try { Thread.sleep(1600); }
            catch (InterruptedException ex) { android.util.Log.d("Catch the Note", ex.toString()); }
    }

    public void playLoop(View v) {
        // Is the sound loaded does it already play?
        if (loaded && !plays) {

            // the sound will play for ever if we put the loop parameter -1
            soundPool.play(soundID, volume, volume, 1, -1, 1f);
            counter = counter++;
            Toast.makeText(this, "Plays loop", Toast.LENGTH_SHORT).show();
            plays = true;
        }
    }

    public void pauseSound(View v) {
        if (plays) {
            soundPool.pause(soundID);
//            soundID = soundPool.load(this, R.raw.beep, counter);
            Toast.makeText(this, "Pause sound", Toast.LENGTH_SHORT).show();
            plays = false;
        }
    }

    public void stopSound(View v) {
        if (plays) {
            soundPool.stop(soundID);
//            soundID = soundPool.load(this, R.raw.beep, counter);
            Toast.makeText(this, "Stop sound", Toast.LENGTH_SHORT).show();
            plays = false;
        }
    }

    public class InputFilterMinMax implements InputFilter {

        private int min, max;

        public InputFilterMinMax(int min, int max) {
            this.min = min;
            this.max = max;
        }

        public InputFilterMinMax(String min, String max) {
            this.min = Integer.parseInt(min);
            this.max = Integer.parseInt(max);
        }

        @Override
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
            try {
                int input = Integer.parseInt(dest.toString() + source.toString());
                if (isInRange(min, max, input))
                    return null;
            } catch (NumberFormatException nfe) { }
            return "";
        }

        private boolean isInRange(int a, int b, int c) {
            return b > a ? c >= a && c <= b : c >= b && c <= a;
        }
    }
    }