Dividir código do programa em vários arquivos e chamá-los quando preci

[lgdelai]

Olá Gente, Estou com uma dúvida que com certeza é boba mas eu não estou conseguindo implementar.

Estou desenvolvendo um player de vídeo no android, porém eu fiz praticamente todo o código em um único arquivo.

Agora quero melhorar a estrutura do sistema e separar as funções em arquivos separados e só chama-las quando precisar.

Por exemplo:

* 01 - No código da activity principal está o codigo que oculta a barra de navegação,

* 02 - existe outro que cria os diretórios que o programa irá usar,

* 03 - outro define o endereço da playlist e verifica se ela existe além de copiar seu conteúdo

para uma lista que será usada pelo player.

* 04 - em outro código inicia a reprodução dos vídeos.

Gostaria de separar estas funções mas não estou conseguindo, o máximo que consegui foi

chamar a activity da splashscreen, mas não estou conseguindo chamar a que oculta a barra

de navegação, a tela da uma piscada e o app não é executado.

Vamos começar pelo código que oculta a barra de navegação? depois vamos para os demais,

talvez nem precise, e eu já consiga entender como fazer com a ajuda de vocês.

Abaixo vou postar 04 códigos:

01 - o ORIGINAL onde tudo funciona mas está no mesmo arquivo.

02 - o NOVO onde estou separando e já consigo chamar a splash screen, mas quando chama

a parte que oculta a barra de navegação da erro.

03 - Código da SplashScreen chamada pelo novo código (02).

04 - Código para ocultar a barra.

Obrigado a quem puder ajudar.

01 - o ORIGINAL onde tudo funciona mas está no mesmo arquivo.

```

package delai.org.delaitvplayer;


import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;


import android.media.MediaPlayer;
import android.os.Bundle;
import android.os.Environment;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.view.Gravity;
import android.view.View;
import android.widget.VideoView;
import android.widget.Toast;
//import android.net.Uri;
//import android.view.Menu;
//import android.widget.MediaController;


public class MainActivity extends Activity
{
// Estas variáveis são usadas pelo VidewView.
private VideoView video;
private List<String> list;
private int count = 1;


// Esta linha é necessária para que a linha "getWindow()..." oculte a barra de navegação 
// Quando esta Activity for aberta. 
@SuppressLint({ "NewApi", "InlinedApi" })


@Override
public void onCreate(Bundle b)
{
super.onCreate(b);






/** OCULTANDO A BARRA DE NAVEGAÇÃO DO TABLET - INICIO
* ------------------------------------------------------------*/ 
/* Esta linha faz com que a barra de navegação do tablet seja ocultada logo que
* esta Activity é iniciada,
* No emulador com android 2.2 o app travou por causa dela */


getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
/** OCULTANDO A BARRA DE NAVEGAÇÃO DO TABLET - FIM
* ------------------------------------------------------------*/ 




/* As barras de status e de título foram removidas diretamente no arquivo "Manifest",
* foi add a linha: "android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
* na Activity do reprodutor de vídeos, a mesma onde está o "SurfaceView", pois só assim
* a parte de baixo da tela que não foi preenchida pelo vídeo ficou escura.
* Quando utilizei o outro método adicionando os comandos aqui o fundo ficava branco. */






/** CRIANDO AS PASTAS DO APP - INICIO
* ------------------------------------------------------------*/ 
// Necessita importar "import android.os.Environment"
// Necessita adicionar permissão abaixo no android manifest:
/** --------------------------------------------------------------------------------   
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
------------------------------------------------------------------------------------- */ 
// Cria pasta "dtvplayer" no SD card "memória interna", 
new File(Environment.getExternalStorageDirectory(), "dtvplayer" ).mkdir();
// Cria pasta "videos" dentro da pasta "dtvplayer"
new File("mnt/sdcard/dtvplayer/", "videos" ).mkdir();
// Cria pasta "files" dentro da pasta "dtvplayer"
new File("mnt/sdcard/dtvplayer/", "files" ).mkdir(); 
/** CRIANDO AS PASTAS DO APP - FIM
* ------------------------------------------------------------*/ 






/** DEFININDO ENDEREÇO DO ARQUIVO PLAYLIST.TXT - INICIO
* ------------------------------------------------------------*/ 
/* Instanciando o objeto do tipo File, aqui é definido onde está 
  localizada a playlist.txt e o nome do objeto que contém o 
  endereço, neste caso o objeto se chama "playList". */
File playList = new File("mnt/sdcard/dtvplayer/files/","playlist.txt"); 
/** DEFININDO ENDEREÇO DO ARQUIVO PLAYLIST.TXT - FIM
* ------------------------------------------------------------*/ 






// VERIFICANDO SE O ARQUIVO PLAYLIST EXISTE
// Se o arquivo "playlist.txt" existir...
if (playList.exists()) 
{ 
// Segue tentando copiar o conteúdo dele para a string list. 






/** PASSANDO A PLAYLIST DO ARQUIVO TXT PARA A STRING LIST - INICIO
* ------------------------------------------------------------*/ 
// Criando a lista
list = new ArrayList<String>();
// As classes FileReader e BuferedReader servem para ler arquivos de texto.
FileReader fr = null;
try
{
// Construtor que recebe o objeto do tipo File "playList" contendo
// o endereço do arquivo "playlist.txt".
fr = new FileReader(playList);
// Construtor que recebe o objeto do tipo FieReader "fr".
BufferedReader br = new BufferedReader(fr);
// Laço "while" que vai copiar os dados do arquivo de texto para a lista.
// Enquanto houver mais linhas para ler...
while (br.ready())
{
// A proxima linha será lida...
String linha = br.readLine();
// E o conteúdo adicionado na lista "list" a partir da 2ª posição,
// como a lista inicia em "0" a 2ª posição é "1", a 3ª é "2", assim por diante.
list.add(linha);
}// FIM DO WHILE


// Fechando os recursos FileReader e BuferedReader.
br.close();
fr.close();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
/** PASSANDO A PLAYLIST DO ARQUIVO TXT PARA A STRING LIST - FIM
* ------------------------------------------------------------*/ 






/** INICIANDO A REPRODUÇÃO DOS VÍDEOS - INÍCIO
* ------------------------------------------------------------*/ 
// Instanciando o player.
     video = new VideoView(this);
setContentView(video);
// Executando o reprodutor de vídeo pela primeira vez.  
callVideo();
/** INICIANDO A REPRODUÇÃO DOS VÍDEOS - FIM
* ------------------------------------------------------------*/ 






/** LISTENER PARA EFETUAR O LOOP - INICIO
 * ------------------------------------------------------------*/ 
video.setOnCompletionListener(
new MediaPlayer.OnCompletionListener()
{
// Assim que o vídeo for concluido. 
public void onCompletion(MediaPlayer mp)
{ 
// Não sei para que server este código, perguntar thiengo.
// if(mp != null)  { mp.reset(); }


// O reprodutor de vídeo será executado novamente.
callVideo();
}// FIM DO PUBLIC VOIDON COMPLETION(MEDIAPLAYER MP)
}// FIM DO NEW MEDIAPLAYER.ONCOMPLETIONLISTENER 
);// FIM DO VIDEO.SETONCOMPLETIONLISTENER  
/** LISTENER PARA EFETUAR O LOOP - FIM
 * ------------------------------------------------------------*/ 






} // FIM DO IF(!PLAYLIST.EXISTS()) "Se arquivo playlist.txt existir" 
// Caso não exista o arquivo playlist.txt...
else
{
// Exibe mensagem informando...
Toast.makeText(getApplicationContext(), "ARQUIVO   ''playlist.txt''  NÃO ENCONTRADO" , Toast.LENGTH_LONG).show();
// E encerra o programa.
finish();
}






}  //FIM DO PUBLIC VOID ONCREATE...






/** REPRODUTOR DE VÍDEO - INICIO
 * ------------------------------------------------------------*/ 
/* Necessário para acessar o endereços do sdcard e ocultar a barra
* de navegação sempre que um novo vídeo se inicia */
@SuppressLint({ "SdCardPath", "NewApi", "InlinedApi" })


private void callVideo()
{
// Reprodutor é finalizado para começar o novo vídeo.
video.stopPlayback();
// A String videoDir recebe o endereço da pasta dos vídeos.
String videosDir = "/mnt/sdcard/dtvplayer/videos/";
// A String VideoName recebe o nome do próximo vídeo que será 
// reproduzido baseado no count que representa a posição atual
// da lista. 
String videoName = list.get(count);


// VERIFICA SE A LINHA ATUAL DA LISTA É NULA OU VAZIA.
// Enquanto a linha estiver NULL ou VAZIA... 
while(videoName == null || videoName.trim().equals(""))
{
// Exibe uma mensagem informando que a linha está vazia ou nula.
// Criei um Toast personalizado para ficar no canto inferior esquerdo da tela.
Toast customToast = new Toast(getBaseContext());
customToast = Toast.makeText(getBaseContext(), "LINHA   " + count + "   VAZIA", Toast.LENGTH_LONG);
customToast.setGravity(Gravity.BOTTOM|Gravity.LEFT, 0, 0);
customToast.show();


//Incrementa "1" ao contador... 
count++;
// videoName recebe o nome do próximo vídeo, correspondente a posição atual do "count".
videoName = list.get(count);
}


// VERIFICAR SE O VÍDEO EXISTE.
// Cria um objeto File contendo o endereço do vídeo atual.
File file =  new File(videosDir + videoName);
// Enquanto o vídeo não existir...
while (!file.exists())
{
// Exibe uma mensagem informando qual o arquivo não existe.
// Criei um Toast personalizado para ficar no canto inferior esquerdo da tela.
Toast customToast = new Toast(getBaseContext());
customToast = Toast.makeText(getBaseContext(), "ARQUIVO NÃO ENCONTRADO:     " + videoName , Toast.LENGTH_LONG);
customToast.setGravity(Gravity.BOTTOM|Gravity.LEFT, 0, 0);
customToast.show();
//Incrementa "1" ao contador... 
count ++;
// videoName recebe o nome do próximo vídeo, correspondente a posição atual do "count".
videoName = list.get(count);
// Objeto "file" recebe o endereço completo do próximo vídeo para nova verificação...
file =  new File(videosDir + videoName);
}


// APÓS GARANTIDO QUE NÃO HÁ LINHA VAZIA E O ARQUIVO EXISTE O CÓDIGO SEGUE PARA REPRODUÇÃO.
// As Strings "videoDir" e "videoName" são unidas para indicar
// o caminho completo do próximo vídeo a ser reproduzido. 
video.setVideoPath(videosDir + videoName);
// É iniciada a reprodução do vídeo constante no VideoPath.
video.start();
// Verifica se a lista chegou ao fim.
if(count+1 < list.size())
{
// se não, add "1" ao contador.
count++;
}// FIM DO IF
else
{
// Se chegou ao fim, volta o contador para a primeira posição da lista.
// para reproduzir desde o início novamente.
count = 1;
}// FIM DO ELSE
/* Esta linha faz com que a barra de navegação do tablet seja ocultada
* sempre que um vídeo novo se inicia */
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
}// FIM DO PRIVATE VOID CALLVIDEO
/** REPRODUTOR DE VÍDEO - FIM
 * ------------------------------------------------------------*/






}// FIM DO PUBLIC CLASS MAINACTIVITY...

```

02 - o NOVO onde estou separando e já consigo chamar a splashscreen, mas quando chama

a parte que oculta a barra de navegação da erro.

```

package delai.org.delaitvplayer;


import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;




public class ActivityPrincipal extends Activity
{
 /* Esta classe "ActivityPrincipal" é classe inicial do app, ela é executada antes de
 * todas e é ela que vai chamar as demais.
 * Ela é agora a classe principal, pois é a primeira a ser executada, então devem
 * ser modificadas algumas linhas no Manifest, adicionando esta activity como principal
 * mas mantendo as antigas classes no manifest, ficou assim: */
/** ACTIVITY PRINCIPAL (ActivityPrincipal.java):
   --------------------------------------------------------------------------- 
   <activity
        android:name="delai.org.delaitvplayer.ActivityPrincipal"
        android:label="@string/app_name" 
        android:screenOrientation="landscape" 
        android:configChanges="orientation" 
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" >


<intent-filter>
         <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
   ---------------------------------------------------------------------------
    <activity
        android:name="delai.org.delaitvplayer.SplashScreen"
        android:label="@string/app_name" 
        android:screenOrientation="landscape" 
        android:configChanges="orientation" 
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" />
   ---------------------------------------------------------------------------
    <activity android:name="delai.org.delaitvplayer.MainActivity"
              android:label="@string/app_name"
           android:screenOrientation="landscape" 
              android:configChanges="orientation" 
     android:theme="@android:style/Theme.NoTitleBar.Fullscreen"/>
-------------------------------------------------------------------------- */




    @Override
public void onCreate(Bundle savedInstanceState)
    {
     super.onCreate(savedInstanceState);
     /** CHAMANDO A ACTIVITY QUE OCULTA A BARRA DE NAVEGAÇÃO - INICIO 
            --------------------------------------------------------------*/
            Intent i1 = new Intent(ActivityPrincipal.this, OcultaBarraNavegacao.class);
            startActivity(i1);
     /** CHAMANDO A ACTIVITY QUE OCULTA A BARRA DE NAVEGAÇÃO - FIM
     *-------------------------------------------------------------*/
            
     /** CHAMANDO A ACTIVITY SPLASHSCREEN - INICIO
            * ------------------------------------------------------------*/
            Intent i2 = new Intent(ActivityPrincipal.this, SplashScreen.class);
            startActivity(i2);
     /** CHAMANDO A ACTIVITY SPLASHSCREEN - FIM
     *-------------------------------------------------------------*/            


            
    } //FIM DO PUBLIC VOID ON CREATE...
} //FIM DO PUBLIC CLASS ACTIVITYPRINCIPAL...

```

03 - Código da SplashScreen chamada pelo novo código (02).

```

package delai.org.delaitvplayer;


import android.app.Activity;
import android.os.Bundle;
import android.view.MotionEvent;




public class SplashScreen extends Activity
{
private Thread mSplashThread; 
    private boolean mblnClicou = false;


/* Esta classe "SplashScreen" é da tela de apresentação do app, ela vai ficar sendo 
 * exibida enquanto o programa é iniciado e executa tarefas de segundo plano.
 * Ela também foi adicionada no manifest e ficou assim: */
/** ACTIVITY SPLASH SCREEN:
   ---------------------------------------------------------------------------
        <activity
         android:name="delai.org.delaitvplayer.SplashScreen"
         android:label="@string/app_name" 
         android:screenOrientation="landscape" 
         android:configChanges="orientation" 
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" />
   ---------------------------------------------------------------------------*/


    
    @Override
public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_splashscreen);




        /** EXIBINDO A TELA DE SPLASH E CHAMANDO A PRINCIPAL - INICIO
        *------------------------------------------------------------*/ 
        // Thread para mostrar uma tela de Splash
        mSplashThread = new Thread()
        {
            @Override
            public void run()
            {
            /* try {
                     synchronized(this)
                     {
                     Espera por 2 segundos ou sai quando o usuário tocar na tela.
                     wait(3000);
                     mblnClicou = true;
                     }
             }// FIM DO TRY SYNCRHONIZED  
                catch(InterruptedException ex)
                {
                }// FIM DO CATCH SYNCHRONIZED   */
                if (mblnClicou)
                {
                 // Fechar a tela de Splash.
                    finish();


                    /* Carrega a classe MainActivity (que exibe os vídeos)
                    Intent i = new Intent();
                    i.setClass(SplashScreen.this, MainActivity.class);
                    startActivity(i); */
                }// FIM DO IF(MBINCLICOU)
            }// FIM DO PUBLIC VOID RUN
        }; // FIM DO MSPLASTHREAD...
         
        mSplashThread.start();
    }// FIM DO PUBLIC VOID ON CREATE...
   
    @Override
    public void onPause()
    {
        super.onPause();
         
        // Garante que quando o usuário clicar no botão "Voltar" o sistema deve finalizar a thread
        mSplashThread.interrupt();
    }// FIM DO PUBLIC VOID ONPAUSE
     
    @Override
    public boolean onTouchEvent(MotionEvent event)
    {
        if (event.getAction() == MotionEvent.ACTION_DOWN)
        {
         // O método abaixo está relacionado a thread de splash
         synchronized(mSplashThread)
         {
         mblnClicou = true;
         // O método abaixo finaliza o comando wait
         // Mesmo que ele não tenha terminado sua espera
         mSplashThread.notifyAll();
         }// FIM DO SYNCHRONIZED(MSPLASHTHREAD)             
        }// FIM DO IF(EVENT.GERACTION()...
        return true;
    }// FIM DO PUBLIC BOOLEAN ONTOUCHEVENT...
    /** EXIBINDO A TELA DE SPLASH E CHAMANDO A PRINCIPAL - FIM
    *------------------------------------------------------------*/ 


    
    
}// FIM DO PUBLIC CLASS SPLASHSCREEN...

```

04 - Código para ocultar a barra.

```

package delai.org.delaitvplayer;


import android.annotation.SuppressLint;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;




public class OcultaBarraNavegacao extends Activity
{
/* Esta Activity "OcultaBarraNavegacao" vai ocultar a barra inferior de navegacao
 * do dispositivo. ela também deve ser adicionana no manifest logo abaixo das
 * activitys que já estão lá como SplashScreen, ActivityPrincipal etc. ficou assim: */
/** ACTIVITY OcutarBarraNavegacao:
   ---------------------------------------------------------------------------
        <activity
         android:name="delai.org.delaitvplayer.OcultarBarraNavegacao"
         android:label="@string/app_name" 
         android:screenOrientation="landscape" 
         android:configChanges="orientation" 
android:theme="@android:style/Theme.NoTitleBar.Fullscreen" />
-------------------------------------------------------------------------- */
    
// Esta linha é necessária para que a linha "getWindow()..." abaixo funcione e oculte a barra de navegação
    @SuppressLint({ "NewApi", "InlinedApi" })


    
    @Override
public void onCreate(Bundle savedInstanceState)
    {
     /** OCULTANDO A BARRA DE NAVEGAÇÃO DO TABLET OU ANDROID MINI PC - INICIO
     *------------------------------------------------------------*/ 
        /* Esta linha faz com que a barra de navegação do tablet seja ocultada logo que
         * esta Activity é iniciada,
         * No emulador com android 2.2 o app travou por causa dela */
        getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
        /** OCULTANDO A BARRA DE NAVEGAÇÃO DO TABLET OU ANDROID MINI PC - FIM
        *------------------------------------------------------------*/ 
    }// FIM DO PUBLIC VOID ON CREATE...
    
    
}// FIM DO PUBLIC CLASS OCULTABARRANAVEGACAO...

```