Quellcode

Download der Projekt Dateien:

Link zum gepackten Eclipse Projekt

Droid_Dice.java

package com.DroidDice;

//-------------------------Implementierung von benötigten Android Standard-Klassen-------------------------------------------------

import android.app.Activity;

import android.os.Bundle;

import java.io.IOException;

import java.util.Date;

import java.util.Random;

import java.util.Timer;

import java.util.TimerTask;

import android.media.AudioManager;

import android.media.MediaPlayer;

import android.os.Vibrator;

import android.text.Layout;

import android.util.Log;

import android.view.KeyEvent;

import android.view.Window;

import android.view.WindowManager;

import android.widget.LinearLayout;

import android.widget.TextView;

import android.content.Context;

import android.content.res.Resources;

import android.graphics.Typeface;

import android.graphics.drawable.Drawable;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

//-------------------------End------------------------------------------------------------------------------------

//-------------------------Haupt-Klasse------------------------------------------------------------------------

public class Droid_Dice extends Activity implements SensorEventListener

{

//-------------------------Attribute/Variablen deklaration--------------------------------------------------------

//---Standbyvariablen------------------------------- //Diese Variablen werden benötigt um die "Bitte Würfeln" Aufforderung

boolean ruhe_mid; //zu deaktivieren, wenn das Gerät still auf dem Tisch liegt

int index_ruhe;

//---Medienvariablen---------------------------------

private MediaPlayer mPlayer; //Funktion wird benötigt um mp3s aufzurufen

private final String LOG_TAG = "AudioRecordTest"; //wird zur Fehlermeldung benötigt

int int_case;

//---Vibrationsvariablen---------------------------------

Vibrator vibro;

//Pattern für Vibrationsmuster long lArray[] = {aus,an,aus,...

long lArray1[] = { 10, 600, 1000, 200 };

long lArray2[] = { 10, 600, 1000, 200, 200, 200 };

long lArray3[] = { 10, 600, 1000, 200, 200, 200, 200, 200 };

long lArray4[] = { 10, 600, 1000, 200, 200, 200, 200, 200, 200, 200 };

long lArray5[] = { 10, 600, 1000, 200, 200 ,200 ,200 ,200 ,200 ,200 ,200 ,200 };

long lArray6[] = { 10, 600, 1000, 200, 200 ,200 ,200 ,200 ,200 ,200 ,200 ,200 ,200 ,200 };

//---Bewegungs-Sensor-Variablen-----------------------------

private SensorManager sensorManager = null;

boolean messung_aktiv;

boolean gewuerfelt; //true wenn stark genug geschüttelt

boolean pause;

int empfindlichkeit = 14; //Empfindlichkeitseinstellung für Bewegungsdetektion

int zaehler = 7; //Anzahl der nötigen Bewegungen um ein Schütteln zu erkennen

int bewegungja = 0; //Zaheler für Bewegungsdetektion

float gx = 0; //Beschleunigungswert in x-Richtung

float gy = 0; //Beschleunigungswert in y-Richtung

float gz = 0; //Beschleunigungswert in z-Richtung

boolean weitergabe;

boolean wuerfeln_start;

//---Zeitvariablen----------------------------------//Variablen werden für verschiedene Zeitbestimmungen benötigt

Date today_messung;

double ja=1E12;

double zeit_neu;

double zeit_alt;

double zeit_aufforderung;

double zeit_wuerfeln;

double zeit_warten;

int int_verzoegerung;

int ausgabezeit;

//---Allgemeine Variablen----------------------------------

int zufallszahl; //Zahl die der Zufallsgenerator ausgibt

//---Bildschirm Variablen---------------------------------- //Variablen um die Würfelbilder zuzuweisen

Drawable drawable0;

Drawable drawable1;

Drawable drawable2;

Drawable drawable3;

Drawable drawable4;

Drawable drawable5;

Drawable drawable6;

LinearLayout linearLayout;

//-------------------------End Attribute deklaration--------------------------------------------------------------

AudioManager audioManager;

//-------------------------Methode onCreate-----------------------------------------------------------------------

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) // Funktion on Create wird als erstes aufgerufen bei Öffnen der Applikation

{

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE); //Entfernt Titelzeile am Oberen Bildschirmrand

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN); //Entfernt Statuszeile am Oberen Bildschirmrand

setContentView(R.layout.main); //Festlegung der Hauptoberfläche main.xml

Resources res = getResources(); //Ab hier: Zuweisung der Bildfiles zu den jeweiligen Variablen

drawable0 = res.getDrawable(R.drawable.wuerfel3); //

drawable1 = res.getDrawable(R.drawable.wuerfel_1); //

drawable2 = res.getDrawable(R.drawable.wuerfel_2); //

drawable3 = res.getDrawable(R.drawable.wuerfel_3); //

drawable4 = res.getDrawable(R.drawable.wuerfel_4); //

drawable5 = res.getDrawable(R.drawable.wuerfel_5); //

drawable6 = res.getDrawable(R.drawable.wuerfel_6); //bis hier

linearLayout = (LinearLayout)findViewById(R.id.LinearLayout02); //

linearLayout.setBackgroundDrawable(drawable0); // Anzeigen des Standard-Hintergrundes

sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); //Funktionen für Beschleunigungssensor Nutzung

sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_UI);

vibro = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); //Funktion für Vibrationsmotor ansteuerung

today_messung=new Date(); //Anlegen einer Datumsvariable

zeit_aufforderung=(today_messung.getTime()-ja); //Zeit der Datumsvariable wird in mSec ausgegeben

audioManager=(AudioManager) getSystemService(Context.AUDIO_SERVICE);

//Konstanthalten der Ausgabelautstärke

audioManager.setStreamVolume(AudioManager.STREAM_RING,audioManager.getStreamMaxVolume(AudioManager.STREAM_RING), AudioManager.FLAG_ALLOW_RINGER_MODES|AudioManager.FLAG_PLAY_SOUND);

audioManager.setStreamVolume(AudioManager.STREAM_MUSIC,audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC), AudioManager.FLAG_ALLOW_RINGER_MODES|AudioManager.FLAG_PLAY_SOUND);

}

//-------------------------End Methode onCreate--------------------------------------------------------------------

/*---------------Funktion für Zufallsgenerator-------------------------------------------------------------------*/

public void erstelleZufallsZahl()

{

Random zufallsgenerator = new Random();

for(int i=0; i<1; i++)

{

int zahl = zufallsgenerator.nextInt(6);

// System.out.println(zahl);

zufallszahl = zahl+1;

}

/*---------------Ende Zufallsgenerator---------------------------------------------------------------------------*/

//-------------------------Methode MP3-----------------------------------------------------------------------------

public void MP3_Starten() //in dieser Funktion wird der Mediaplayer gestartet und über die switch/case Anweisung das

//jeweilige MP3 abgespielt und festgelegt wann der Mediaplayer wieder gestoppt wird

{ //desweiteren wird der jeweilige Vibrationsrhythmus gestartet und die gewürfelten Augen auf

//den Display anzeigen

try

{

mPlayer = new MediaPlayer();

switch (int_case)

{

case 7:

mPlayer.setDataSource("/sdcard/music/droid_dice/bitte_wuerfeln.mp3");

break;

case 1:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_1.mp3");

linearLayout.setBackgroundDrawable(drawable1);

vibro.vibrate(lArray1, -1);

ausgabezeit=2000;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

case 2:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_2.mp3");

linearLayout.setBackgroundDrawable(drawable2);

vibro.vibrate(lArray2, -1);

ausgabezeit=2400;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

case 3:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_3.mp3");

linearLayout.setBackgroundDrawable(drawable3);

vibro.vibrate(lArray3, -1);

ausgabezeit=2800;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

case 4:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_4.mp3");

linearLayout.setBackgroundDrawable(drawable4);

vibro.vibrate(lArray4, -1);

ausgabezeit=3200;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

case 5:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_5.mp3");

linearLayout.setBackgroundDrawable(drawable5);

vibro.vibrate(lArray5, -1);

ausgabezeit=3600;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

case 6:

mPlayer.setDataSource("/sdcard/music/droid_dice/eine_6.mp3");

linearLayout.setBackgroundDrawable(drawable6);

vibro.vibrate(lArray6, -1);

ausgabezeit=4000;

zeit_warten=zeit_neu;

int_verzoegerung=2300;

Zeitverzoegerung2();

break;

default:

break;

}

mPlayer.prepare();

mPlayer.start();

}

catch (IOException e) // wird benötigt um bei einem Fehlerhaften Dateizugriff ein Fehlerprotokoll zu erzeugen

{

Log.e(LOG_TAG, "prepare() failed");

}

//-------------------------End Methode MP3-------------------------------------------------------------------------

//-------------------------Methode Zeit abbrechen------------------------------------------------------------------

public void Zeitverzoegerung() //Methode um nach aufheben des in ruhe liegenden Gerätes zeitverzögert eine

//"Bitte Würfeln" Aufforderung auszugeben

{

Timer timing = new Timer();

timing.schedule(new TimerTask()

{

@Override

public void run()

{

MP3_Starten();

zeit_aufforderung=zeit_neu;

}

},int_verzoegerung);

}

//-------------------------End Zeit abbrechen----------------------------------------------------------------------

//-------------------------Methode Zeit abbrechen2------------------------------------------------------------------

public void Zeitverzoegerung2() //Methode um den Mediaplayer bei verschieden langen MP3 Ansagen gezielt zu stoppen

{

Timer timing = new Timer();

timing.schedule(new TimerTask()

{

@Override

public void run()

{

if (mPlayer != null)

{

mPlayer.release();

mPlayer = null;

}

},int_verzoegerung);

}

//-------------------------End Zeit abbrechen2----------------------------------------------------------------------

//-------------------------Methode Camera-/Volumebutton off-------------------------------------------------------

@Override //Methode um die seitlichen Tasten während des Programmablaufs zu deaktivieren

public boolean onKeyDown(int keyCode, KeyEvent event)

{

if (keyCode == KeyEvent.KEYCODE_CAMERA)

{

return true; // do nothing on camera button

}

if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN)

{

return true; // do nothing on camera button

}

if (keyCode == KeyEvent.KEYCODE_VOLUME_UP)

{

return true; // do nothing on camera button

}

return super.onKeyDown(keyCode, event);

}

//-------------------------End Methode Camera-/Volumebutton off---------------------------------------------------

//-------------------------------Methode onSensorChanged-----------------------------------------------------------

@Override //Funktion wird bei jeder Sensorwert-Änderung aufgerufen, da der Sensor jedoch rauscht,

//wird hier die volle eingestellte Aktualisierungsrate von 15Hz ausgenutzt

public void onSensorChanged(SensorEvent event)

{

today_messung=new Date();

zeit_neu=(today_messung.getTime()-ja);

gx = event.values[0]; //Beschleunigungswerte in x,y,z-Richtung auslesen und zuweisen

gy = event.values[1];

gz = event.values[2];

//Startbedingung //Gerät liegt flach auf dem Tisch --> messung_aktiv==false

if(!messung_aktiv)

{

if(Math.abs(gz)<9.8)

{

messung_aktiv=true;

int_verzoegerung=100;

int_case=7;

Zeitverzoegerung();

zeit_aufforderung=zeit_neu;

}

if(messung_aktiv) //Gerät wurde aufgenommen --> messung_aktiv==true

{

//-------------Start der Inaktivitätsprüfung-------------------

if( (Math.abs(gz)>9.8) && (ruhe_mid==false) ) //Funktion überprüft ob Gerät inaktiv ist oder damit gewürfelt werden soll

{

ruhe_mid=true;

zeit_alt=zeit_neu;

index_ruhe=0;

}

if(ruhe_mid)

{

if( (Math.abs(gz)>9.8) && ((zeit_neu-zeit_alt)<8000))

{

index_ruhe++;

}

if(((zeit_neu-zeit_alt)>8000) && (index_ruhe>100))

{

messung_aktiv=false;

ruhe_mid=false;

index_ruhe=0;

}

if(((zeit_neu-zeit_alt)>8000) && (index_ruhe<100))

{

ruhe_mid=false;

index_ruhe=0;

}

//-------------Ende der Inaktivitätsprüfung-------------------

if( ((zeit_neu-zeit_aufforderung)>6000) && ((weitergabe==true)|| wuerfeln_start==false ) ) //zyklisches Ausgeben von "Bitte würfeln"

{

zeit_aufforderung=zeit_neu;

weitergabe=false;

gewuerfelt=false;

int_case=7;

MP3_Starten();

}

//Bewegungsdetektion

if(gewuerfelt==false) //Funktion wird nur aufgerufen wenn gerade kein Würfeln erkannt wurde

{

if((Math.sqrt(Math.pow(gx,2)+Math.pow(gy,2)+Math.pow(gz,2))>empfindlichkeit) && (wuerfeln_start==false) ) //erste aussreichend starke (Amplitude > Empfindlichkeit)

//Schüttel-Flanke wird erwartet

{

zeit_wuerfeln=zeit_neu;

wuerfeln_start=true;

}

if(((zeit_neu-zeit_wuerfeln)<2000) && (bewegungja < zaehler) && wuerfeln_start==true) //Bewegungszähler wird innerhalb von 2sek hochgezählt

{

if(Math.sqrt(Math.pow(gx,2)+Math.pow(gy,2)+Math.pow(gz,2))>empfindlichkeit) //Bewegungserkennung wenn Summe der absoluten Beschleunigung über Grenzwert

{

bewegungja++;

zeit_aufforderung=zeit_neu;

}

if(bewegungja >= zaehler) //wenn Bewegungszähler Grenze überschreitet wird ein "Gewürfelt-Flag" gesetzt und der Zähler zurückgesetzt

{

bewegungja = 0;

gewuerfelt=true;

//pause=true;

}

if(((zeit_neu-zeit_wuerfeln)>2000) && bewegungja<zaehler && wuerfeln_start==true) //wenn innerhalb von 2sek nicht aussreichend geschüttelt wurde, Rücksetzen der Variablen

{

zeit_aufforderung=zeit_neu;

bewegungja=0;

wuerfeln_start=false;

}

if ((gewuerfelt==true) && (weitergabe==false)) //Erzeugen der Zufallszahl und anschließendes Weitergeben an Audioausgabe und Vibration

{ //Rücksetzen des "Gewürfelt-Flags" um auf neues Würfeln zu warten

gewuerfelt=false;

zeit_aufforderung=zeit_neu;

erstelleZufallsZahl();

int_case=zufallszahl;

if (mPlayer != null)

{

mPlayer.release();

mPlayer = null;

}

MP3_Starten();

}

if((zeit_neu-zeit_warten)<ausgabezeit) //Blockieren des Zählers, solange Ergebnis noch ausgegeben wird

{

bewegungja = 0;

}

@Override

public void onAccuracyChanged(Sensor sensor, int accuracy)

{

// TODO Auto-generated method stub

}

//-------------------------------End Methode onSensorChanged-------------------------------------------------------

//#######################################################----Methoden Beenden (Destruktoren) ----###################################

@Override

protected void onResume()

{

super.onResume();

audioManager.setStreamVolume(AudioManager.STREAM_RING,audioManager.getStreamMaxVolume(AudioManager.STREAM_RING), AudioManager.FLAG_ALLOW_RINGER_MODES|AudioManager.FLAG_PLAY_SOUND);

audioManager.setStreamVolume(AudioManager.STREAM_MUSIC,audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC), AudioManager.FLAG_ALLOW_RINGER_MODES|AudioManager.FLAG_PLAY_SOUND);

}

@Override

protected void onPause() //bei Druck auf die "Home" Taste wird das Programm beendet

{

super.onPause();

finish();

}

@Override

protected void onDestroy() //bei Druck auf die "Zurück" Taste wird das Programm beendet

{

super.onDestroy(); //Destruktoren für Sensoren und Mediaplayer

sensorManager.unregisterListener(this);

if (mPlayer != null)

{

mPlayer.release();

mPlayer = null;

}

//--------------------------------------End------------------------------------------------------------------------

}