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

[lgdelai 0]

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...

```