Eigene Programmvorstellungen und fertige Codeschnipsel...

Zuletzt bearbeitet:
Sry für Doppelpost.
 
Zuletzt bearbeitet:
Womit du nun einen Dreifachpost geschaffen hast;D

Wecker klingt ja mal gut, aber den PC könnte ich nicht die Nacht durchlaufen lassen (leise ist er, aber mein Schlaf nicht sehr tief*lol*).
Ich hab kaum Ahnung was das Schreiben von Programmen angeht, darum frage ich mal interessehalber... Wäre es machbar dem Programm z.B. zu sagen "um 05:30 fährst du den PC wieder hoch und schmeisst den Wecker an"?
 
Den Wecker müsste ich leider nochmal überarbeiten. Da geht nämlich was nicht so wie es soll. :P

Du könntest den Wecker schon so programmieren, dass er per Autostart funktioniert, aber den PC wirst du wohl oder übel mit Zeitschaltuhr versehen müssen (per Hardware).
 
Und wie lässt sich das realisieren?
Gibts da ne Einstellung im BIOS für?
Weil PC+Marantz sollte sogar mich mal pünktlich ausm Bett kriegen ;D
 
Hmmm. Solltest du den Player verwenden wollen, dann musst du dabei aufpassen, dass du die Datei auch wirklich im Verzeichnis starest, indem es sich auf befindet, sonst wird das mit dem mp3 Abspielen nichts...

Wegen der Einstellung im Bios:

Kann ich dir nicht wirklich sagen, denke aber nicht...

Gerade im Netz gefunden (inkl Fehler):

Ich w?rd's so machen:

1. Zeitschaltuhr so einstellen, dass sie immer AN is, ausser eine Minute bevor der PC angehen soll (da is ma eine Minute AUS) und dann im BIOS einstellen, dass der PC angeht, sobald Saft da is

ODER

2. Wenn man nen Server im Haus hat (so wie ich), da ein Programm einrichten, dass den PC per Wake-on-lan einschaltet

Quelle:

http://www.lima-city.de/thread/computer-per-timer-anschalten

EDIT:

Hab grad nochmal extra nachgeschaut. Also in den ACPI Options gibts zumindest bei mir eine Einstellung dafür. Bloß der Wecker von mir kann das noch nicht, da müsstest du dir wohl einen neuen suchen :P.
 
Zuletzt bearbeitet:
Also in meinem Asus P6T kann ich die Einschaltzeit durchaus einstellen. Ich hatte es so eingestellt das der Rechner immer um 7.00 Uhr morgens sich eingeschaltet hat und mittels eines anderen Programms (z.B. Agata Shutdown Pro) um 15.00 Uhr wieder ausgeschaltet wurde. Da brauchste keine Zeitschaltuhr für.
 
Hey, das sind ja mal Neuigkeiten;D
Wenn ich es jetzt dank euch und meiner Musik morgens wieder schaffe pünktlich aufzustehen wäre das doch was*lol*
Ich werd mein BIOS mal nach solchen Funktionen durchforsten, und falls das nicht die erhoffte Wirkung bringt werde ich eben mal gucken ob ich noch eine Zeitschaltuhr finde:)
 
Müsste auch ohne Zeitschaltuhr gehen. Bei MediaPortal z.b. geht der Rechner mit einem Plugin in den Standby-Modus (S3) und wacht 5min vor der programmierten Aufnahme wieder auf.
 
Jep, heute um 07:00 ist der PC angegangen und hat mich so davor gerettet dass ich hoffnungslos verpenn;D
Jetzt fehlt nurnoch die Musik, die Autostartlösung gefällt mir aber nich so gut, weils ein bisschen doof wäre wenn der mir jedesmal losröhrt nur weil ich den PC anschmeiß*lol*

Aber danke schonmal für den guten Tip mit dem BIOS, da wäre ich ja schonmal weiter;D
 
Ein studentischer Verein, in dem ich arbeite, hat eine eigene Software geschrieben, um Sitzungprotokolle einfacher zu schreiben und zu verwalten.
Ein kurzer Umriss in Stichpunkten:
  • Jeder kann eigene Agendapunkte einstellen,
  • das Protokoll wird zu jedem Punkt erstellt,
  • es gibt eine LDAP-Anbindung zur Authentifizierung,
  • läuft z.B. auf einem TomcatServer,
  • das Protokoll wird an alle Teilnehmer verschickt, genauso wie vorab eine Agenda
  • uvm.

Wer Interesse hat, kann die Software bei Sourceforge anschauen bzw. mit einwickeln. Momentan ist erst nur der Source online, da noch 2 Bugs drin sind. Ein Release folgt demnächst.
 
Codeschnipsel:

Java MP3 Player Thread.

Hier zu finden: https://gist.github.com/912328

PHP:
/**
 * @author Martin Braun
 * Player inspired by Matthias Pfisterer's examples on JavaSound
 * (jsresources.org). Because of the fact, that this Software is meant
 * to be Open-Source and I don't want to get anybody angry about me
 * using parts of his intelligence without mentioning it, I hereby
 * mention him as inspiration, because his code helped me to write this class.
*/

import java.io.IOException;
import java.net.URL;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;


public class Player extends Thread
{

private static final int EXTERNAL_BUFFER_SIZE = 128000;
private AudioInputStream audioInputStream;
private SourceDataLine line;
private AudioFormat audioFormat;
private DataLine.Info info;
private boolean pause = false;
private boolean stop = false;

public Player(URL url)
{
try
{
insert(url);
}
catch(Exception e)
{
System.out.println("Error while inserting the URL");
}

}

public void insert(URL url)
{
try
{
audioInputStream = AudioSystem.getAudioInputStream(url);
}
catch (Exception e)
{
System.out.println("Error while parsing URL to File/Stream");
}
if (audioInputStream != null)
{
AudioFormat format = audioInputStream.getFormat();
if ( format.getEncoding() != AudioFormat.Encoding.PCM_SIGNED )
{
AudioFormat newFormat = new AudioFormat(
AudioFormat.Encoding.PCM_SIGNED,
format.getSampleRate(),
16,
format.getChannels(),
format.getChannels() * 2,
format.getSampleRate(),
false );
AudioInputStream newStream = AudioSystem.getAudioInputStream( newFormat, audioInputStream );
format = newFormat;
audioInputStream = newStream;
}
}
audioFormat = audioInputStream.getFormat();
info = new DataLine.Info(SourceDataLine.class,audioFormat);
try
{
line = (SourceDataLine) AudioSystem.getLine(info);
line.open(audioFormat);
line.start();
}
catch(Exception e)
{
System.out.println("Error while starting playback");
}
}

public void run()
{
int nBytesRead = 0;
int bufferSize = EXTERNAL_BUFFER_SIZE;
if(audioFormat != null)
{
bufferSize = (int) audioFormat.getSampleRate() * audioFormat.getFrameSize();
System.out.println(audioFormat);
}
byte[] abData = new byte[bufferSize];
System.out.println("Buffer Size: " + bufferSize);
while (nBytesRead != -1 && !stop && line != null)
{
synchronized(this)
{
                while (pause && !stop)
                {
                 try
                 {
                 System.out.println("paused");
                 wait();
                 }
                 catch(Exception e)
                 {
                 }
                }
                notify();
            }
if(!stop)
{
try
{
nBytesRead = audioInputStream.read(abData, 0, abData.length);
}
catch (IOException e)
{
nBytesRead = -1;
}
if(nBytesRead != -1);
{
try
{
line.write(abData, 0, nBytesRead);
}
catch(IllegalArgumentException e)
{
//Has to be caught, because if the stream ends, there may occur an error,
//that the amount of bytes read is not valid (occurred under OpenJDK).
}
}
}
}
if(line != null)
{
line.drain();
line.close();
}
}

public synchronized void pause()
{
pause = !pause;
if(!pause)
notify();
}

public synchronized void stop_()
{
stop = true;
notify();
}

public synchronized boolean isStopped()
{
return stop;
}

public AudioFormat getAudioFormat()
{
return audioFormat;
}

public AudioInputStream getAudioInputStream()
{
return audioInputStream;
}

}
 
Gewöhn dir mal an mehr zu kommentieren. Der Code ist zwar recht simpel und jetzt bist du noch drin, wie sieht das aber später mal aus?
 
Aye! Der Code stammt noch aus den Anfängen meines Programms, und da habe ich einiges versäumt. Der komplette Thread ist noch wüster... Leider.
 
Dann sieh das jetzt als deine Chance dir das Prinzip des Refactorings anzueignen und dann dauerhaft einzusetzen.

Refactoring ist wie Zähneputzen: du kommst eine zeitlang auch ohne aus, dauerhaft wird das aber nicht durchgehen.
 
Ich hab gerade aus schlechtem Gewissen gerade das Auskommentiert, was ich gestern geschrieben habe.
 
Ich hab gerade mal deinen letzten Commit angesehen: kommentiere nicht jede Zeile. Das verleitet stark dazu zu kommentieren, wie das Programm etwas macht. Das ist aber nicht der Sinn eines Kommentars, denn wie etwas gemacht wird kann jeder halbwegs erfahrene Programmierer aus dem Code lesen. Schreibe größere Kommentarblöcke, in denen du festhälst, was der Code macht und was du versuchst damit zu erreichen.

Das ist wirklich hilfreich, erleichtert das Verständnis von fremdem Code und hilft dir bei der Fehlersuche in Code, den du vor längerer Zeit geschrieben hast. Denn Logikfehler aus dem Programmablauf zu lesen ist schwer; wenn du dir vorher in einem Kommentar klar machst, was du mit dem Code erreichen willst, ist so etwas um einiges einfacher.
 
Meinst du, das reicht, wenn ich es in jeder Methode in

/**
*
*/

dazupinsel?
 
PHP:
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.PointerInfo;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
 
import javax.swing.JFrame;
 
public class Main 
{
    private static int x_coordEvent=-1;
    private static int y_coordEvent=-1;
    private static JFrame frame;
    
    public static void main(String args[])
    {
        frame = new JFrame("Drag me!");
        frame.getContentPane().setLayout(null);
        frame.setUndecorated(true);
        frame.pack();
        frame.setSize(300,200);
        frame.setLocationRelativeTo(null);
        frame.addMouseMotionListener(new MouseMotionListener()
        {
            public void mouseDragged(MouseEvent e) 
            {
                if(x_coordEvent==-1 || y_coordEvent==-1)
                {
                    System.out.println("Initializing");
                    x_coordEvent = e.getX();
                    y_coordEvent = e.getY();
                }
                PointerInfo pointerInfo = MouseInfo.getPointerInfo();
                Point point  = pointerInfo.getLocation();
                int x = (int)point.getX();
                int y = (int)point.getY();
                frame.setLocation(x-x_coordEvent, y-y_coordEvent);
            }
            public void mouseMoved(MouseEvent e) 
            {
                System.out.println("Resetting");
                x_coordEvent = -1;
                y_coordEvent = -1;
            }           
        });
        frame.setVisible(true);
    }
}

Mal ein kleines Beispiel, wie man ein undekoriertes JFrame rumschubst.

Und der Schmarren ist dabei entstanden xD:

http://chili-martin.co.de/file_download/7/OnScreenSnake.jar
 
Zuletzt bearbeitet:
Hallo allerseits,

ich bin derzeit in einem kleinen Coding Spree dabei eine kleine API zu schreiben. Das ganze soll die Verwendung von Java Sound vereinfachen (weil das ist mehr als kompliziert geraten) und trotzdem gut erweiterbar sein. Im Moment gibt es nur die streambasierte Implementierung eines Players, der noch nicht alles kann, was er soll (siehe Code im Repo). Aber mittlerweile traue ich mich das auch hier zu posten :) (vor allem wegen der jetzt vorhandenen Doku). Ein kleines Beispielprogramm verdeutlicht die Einfachheit des Ganzen:

PHP:
package de.hotware.hotsound.examples;

import java.io.File;
import java.net.MalformedURLException;

import de.hotware.hotsound.audio.player.BasicSong;
import de.hotware.hotsound.audio.player.IMusicPlayer;
import de.hotware.hotsound.audio.player.IMusicPlayer.SongInsertionException;
import de.hotware.hotsound.audio.player.IPlaybackListener;
import de.hotware.hotsound.audio.player.StreamMusicPlayer;

/**
 * Player that plays on the command line and it's 37 lines long
 * 
 * @author Martin Braun
 */
public class SimplePlayer {

	public static void main(String[] args) throws MalformedURLException,
			SongInsertionException {
		if(args.length >= 1) {
			IMusicPlayer player = new StreamMusicPlayer(new IPlaybackListener() {

				@Override
				public void onEnd(PlaybackEndEvent pEvent) {
					System.out.println("Playback ended");
					System.exit(1);
				}

			});
			player.insert(new BasicSong(new File(args[0])));
			player.startPlayback();
		}
	}

}

Link zum Repository:
https://github.com/s4ke/HotSound

Was haltet ihr davon? Ist es eine gute Idee sowas zu bauen? Vorschläge? Wünsche?

Gruß Thomas!
 
Kleines Beispiel wie man sich mit der Soundcloud-API in Java zu benehmen hat :)

PHP:
package de.hotware.soundcloud.test;

import java.io.IOException;
import java.net.URL;

import org.apache.http.HttpResponse;
import org.json.JSONException;
import org.json.JSONObject;

import com.soundcloud.api.ApiWrapper;
import com.soundcloud.api.Env;
import com.soundcloud.api.Http;
import com.soundcloud.api.Request;

import de.hotware.hotsound.audio.player.BasicPlaybackSong;
import de.hotware.hotsound.audio.player.IMusicPlayer;
import de.hotware.hotsound.audio.player.ISong;
import de.hotware.hotsound.audio.player.MusicPlayerException;
import de.hotware.hotsound.audio.player.StreamMusicPlayer;

public class SimpleSoundCloudPlayer {

	public static void main(String[] args) throws ClassNotFoundException,
			IOException, MusicPlayerException, JSONException {
		if(args.length == 3) {
			ApiWrapper wrapper = new ApiWrapper("client_id",
					"client_secret",
					null,
					null,
					Env.LIVE);
			
			wrapper.login(args[0], args[1]);
			
			HttpResponse locationResponse = wrapper.get(Request.to("/resolve").with("url", args[2]));		
			JSONObject locationJSON = Http.getJSON(locationResponse);
			
			HttpResponse streamURLResponse = wrapper.get(Request.to(locationJSON.get("location")+"/stream"));
			JSONObject streamURLJSON = Http.getJSON(streamURLResponse);
			
			IMusicPlayer player = new StreamMusicPlayer();
			ISong song = new BasicPlaybackSong(new URL(streamURLJSON.getString("location")));
			player.insert(song);
			System.out.println("Starting playback");
			player.start();
		} else {
			System.out.println("Parameters to be set: 0=username, 1=password, 2=SongURL");
		}
	}
	
}

Da mir die ganze Geschichte so gefällt wirds demnächst zumindest zum Thema Sound und vll auch SoundCloud mehr geben :).
 
Zuletzt bearbeitet:
Ein kleiner Mikorophonabspieler der mit meiner Sound API geschrieben worden ist.

PHP:
package de.hotware.jmicrophone;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.Line;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.Mixer;

import de.hotware.hotsound.audio.data.BasicPlaybackAudioDevice;
import de.hotware.hotsound.audio.data.RecordAudio;
import de.hotware.hotsound.audio.player.IMusicPlayer;
import de.hotware.hotsound.audio.player.ISong;
import de.hotware.hotsound.audio.player.MusicPlayerException;
import de.hotware.hotsound.audio.player.RecordSong;
import de.hotware.hotsound.audio.player.StreamMusicPlayer;

public class MicrophonePlayer implements Runnable {

	@Override
	public void run() {

	}

	public static void main(String[] pArgs) throws LineUnavailableException,
			MusicPlayerException {
		if(pArgs.length > 0) {
			List<Mixer> mixers = RecordAudio.getRecordMixers();
			Map<Mixer, AudioFormat[]> formatsMapped = new HashMap<>();
			for(Mixer mixer : mixers) {
				mixer.open();
				Line.Info[] infos = (Line.Info[]) mixer.getTargetLineInfo();
				mixer.close();
				for(Line.Info info : infos) {
					AudioFormat[] supportedFormats = ((DataLine.Info) info)
							.getFormats();
					formatsMapped.put(mixer, supportedFormats);
				}
			}
			String first = pArgs[0];
			switch(first) {
				case "info": {
					for(Entry<Mixer, AudioFormat[]> entry : formatsMapped
							.entrySet()) {
						Mixer mixer = entry.getKey();
						Mixer.Info mixerInfo = mixer.getMixerInfo();
						System.out.println(mixerInfo);
						for(AudioFormat format : entry.getValue()) {
							System.out.println(format);
						}
					}
					break;
				}
				case "play": {
					IMusicPlayer player = new StreamMusicPlayer();
					Mixer mixer = mixers.get(Integer.valueOf(pArgs[1]));
					AudioFormat from = formatsMapped.get(mixer)[Integer
							.valueOf(pArgs[2])];
					float sampleRate = from.getSampleRate();
					if(sampleRate == AudioSystem.NOT_SPECIFIED) {
						sampleRate = Float.parseFloat(pArgs[3]);
					}
					float frameRate = from.getFrameRate();
					if(frameRate == AudioSystem.NOT_SPECIFIED) {
						frameRate = Float.parseFloat(pArgs[4]);
					}
					AudioFormat format = new AudioFormat(from.getEncoding(),
							sampleRate,
							from.getSampleSizeInBits(),
							from.getChannels(),
							from.getFrameSize(),
							frameRate,
							from.isBigEndian());
					ISong song = new RecordSong(mixer, format, 128000);
					player.insert(song, new BasicPlaybackAudioDevice(null, 128000));
					player.start();
					break;
				}
			}
		}
	}

}
 
Noch ein HotSound Beispiel :)
PHP:
/**
 * File PlaylistPlayer.java
 * ---------------------------------------------------------
 *
 * Copyright (C) 2012 Martin Braun (martinbraun123@aol.com)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * - The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 * - The origin of the software must not be misrepresented.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * TL;DR: As long as you clearly give me credit for this Software, you are free to use as you like, even in commercial software, but don't blame me
 *   if it breaks something.
 */
package de.hotware.hotsound.examples;

import java.io.File;
import java.io.IOException;
import java.util.List;

import de.hotware.hotsound.audio.player.MusicListener;
import de.hotware.hotsound.audio.player.MusicPlayer;
import de.hotware.hotsound.audio.player.Song;
import de.hotware.hotsound.audio.player.MusicEndEvent;
import de.hotware.hotsound.audio.player.MusicExceptionEvent;
import de.hotware.hotsound.audio.player.MusicPlayerException;
import de.hotware.hotsound.audio.player.StreamMusicPlayer;
import de.hotware.hotsound.audio.playlist.PlaylistParser;
import de.hotware.hotsound.audio.playlist.StockParser;

public class PlaylistPlayer {
	
	protected int mCurrent;
	protected List<Song> mPlaylist;
	protected MusicPlayer mMusicPlayer;
	
	public PlaylistPlayer() {
		this.mCurrent = 0;
		this.mMusicPlayer = new StreamMusicPlayer(new MusicListener() {

			@Override
			public void onEnd(MusicEndEvent pEvent) {
				System.out.println(pEvent.getSource() + " ended.");
				int size = PlaylistPlayer.this.mPlaylist.size();
				int current = ++PlaylistPlayer.this.mCurrent;
				try {
					PlaylistPlayer.this.mMusicPlayer.insert(PlaylistPlayer.this.mPlaylist.get(current % size));
					PlaylistPlayer.this.mMusicPlayer.start();
					System.out.println(pEvent.getSource() + " started again.");
				} catch (MusicPlayerException e) {
					e.printStackTrace();
				}
			}

			@Override
			public void onException(MusicExceptionEvent pEvent) {
				pEvent.getException().printStackTrace();
			}
			
		});
	}
	
	public void init(File pFile) throws IOException, MusicPlayerException {
		PlaylistParser parser = StockParser.M3U;
		final List<Song> playlist = parser.parse(pFile);
		if(playlist.size() > 0 ) {
			this.mPlaylist = playlist;
			this.mMusicPlayer.insert(playlist.get(0));
		}
	}
	
	public void start() throws MusicPlayerException {
		this.mMusicPlayer.start();
		System.out.println(this.mMusicPlayer + " started.");
	}
	
	public static void main(String[] pArgs) throws MusicPlayerException, InterruptedException, IOException {
		PlaylistPlayer player = new PlaylistPlayer();
		player.init(new File(pArgs[0]));
		player.start();
	}
	
}
 
Ein kleines Programm, das einen zufälligen Bildschirmhintergrund von Wallbase.cc herunterlädt und setzt (nur getestet unter Windows 7):

Aufzurufen mit:

java -jar WallJayNger.jar <Ordner in den die Bilder sollen> <Timing wann geupdated werden soll in Minuten>

Bsp.:

java -jar WallJayNger.jar wallpapers 5

Kann man ganz leicht in den Autostart packen per Verknüpfung und geht auch ohne Admin Rechte:

Als Ziel angeben (Beispiel):
javaw.exe -jar F:\WallJayNger\WallJayNger.jar F:\wallpapers 5

Bei "Ausführen in" muss der Ordner in dem WallJayNger liegt angegeben sein.

http://getdrunkonmovies.com/files/WallJayNger.zip

PHP:
package de.fsmpi.wallJayNger;

import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.imageio.ImageIO;

public class WallJayNger {

	private static final Logger LOGGER = Logger.getLogger(WallJayNger.class
			.getName());
	private static final String THUMB_NAIL_REGEX = ".*id=\"thumb([\\d]*)\".*";
	private static final String PICTURE_REGEX = ".*src=\"(.*%d.(?:jpg|png|gif))\".*";
	private static final Pattern THUMB_NAIL_PATTERN = Pattern.compile(
			THUMB_NAIL_REGEX, Pattern.DOTALL);
	private static final String WALLPAPER_FILE_NAME = "wallpaper_tmp.bmp";

	public static void main(String[] args) throws IOException,
			InterruptedException {
		final File basePath = new File(args[0]);
		final int timing = Integer.parseInt(args[1]);
		final File bmpPath = new File(basePath, WALLPAPER_FILE_NAME);
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {

			@Override
			public void run() {
				try {
					Calendar calendar = Calendar.getInstance();
					String dateString = calendar.get(Calendar.YEAR) + "_" + 
							calendar.get(Calendar.MONTH) + "_" + 
							calendar.get(Calendar.DAY_OF_MONTH)	+ "_time_" + 
							+ calendar.get(Calendar.HOUR_OF_DAY) + "-"
							+ calendar.get(Calendar.MINUTE) + "-" +
							calendar.get(Calendar.SECOND);
					File tmp = new File(basePath,
							"TEMP_IMAGE_STUFF");
					{
						String wallpaperURL = findRandomWallpaperURL();
						byte[] pictureData = null;
						{
							URL url = new URL(wallpaperURL);
							try (InputStream in = new BufferedInputStream(url
									.openStream());
									ByteArrayOutputStream out = new ByteArrayOutputStream()) {
								byte[] buf = new byte[1024];
								int n = 0;
								while ((n = in.read(buf)) != -1) {
									out.write(buf, 0, n);
								}
								pictureData = out.toByteArray();
							}
						}
						try (FileOutputStream fos = new FileOutputStream(tmp)) {
							fos.write(pictureData);
						}
					}

					{
						BufferedImage originalImage = ImageIO.read(tmp);

						ImageIO.write(originalImage, "bmp", bmpPath);
						ImageIO.write(originalImage, "jpeg", new File(basePath,
								dateString + ".jpg"));
					}

					ProcessBuilder processBuilder = new ProcessBuilder(
							"wallpaper_changer.exe", bmpPath.getAbsolutePath(), String
									.valueOf(2));
					LOGGER.log(Level.INFO, "setting background " + bmpPath.getAbsolutePath());
					processBuilder.redirectErrorStream(true);
					Process pr = processBuilder.start();

					try (BufferedReader reader = new BufferedReader(
							new InputStreamReader(pr.getInputStream()))) {
						String line = null;
						while ((line = reader.readLine()) != null) {
							LOGGER.log(Level.INFO, line);
						}
					}
					pr.waitFor();
				} catch (IOException | InterruptedException e) {
					LOGGER.log(Level.WARNING, e.toString());
				}
			}

		}, 0, 1000 * 60 * timing);
	}

	public static String findRandomWallpaperURL() throws IOException {
		String ret = "";
		int wallpaperId = -1;

		{
			Matcher matcher = THUMB_NAIL_PATTERN
					.matcher(downloadHTMLFromWebsite("http://wallbase.cc/random"));
			if (matcher.find()) {
				LOGGER.log(Level.INFO, "thumbnail regex matched");
				wallpaperId = Integer.parseInt(matcher.group(1));
			} else {
				throw new IOException("couldn't find a random thumbnail");
			}
		}

		{
			String patternString = String.format(PICTURE_REGEX, wallpaperId);
			Pattern pattern = Pattern.compile(patternString, Pattern.DOTALL);
			Matcher matcher = pattern
					.matcher(downloadHTMLFromWebsite("http://wallbase.cc/wallpaper/"
							+ wallpaperId));

			if (matcher.find()) {
				LOGGER.log(Level.INFO, "picture regex matched");
				ret = matcher.group(1);
			} else {
				throw new IOException("couldn't find the wallpaper for id: "
						+ wallpaperId);
			}
		}
		return ret;
	}

	public static String downloadHTMLFromWebsite(String url) throws IOException {
		String ret = "";
		URLConnection connection = new URL(url).openConnection();
		connection.connect();
		try (BufferedReader reader = new BufferedReader(new InputStreamReader(
				connection.getInputStream()))) {

			StringBuffer buffer = new StringBuffer();
			String line = null;
			while ((line = reader.readLine()) != null) {
				buffer.append(line).append("\n");
			}
			ret = buffer.toString();
		}
		return ret;
	}

}


---------- Beitrag hinzugefügt um 21:34 ---------- Vorheriger Beitrag um 12:49 ----------

Mann, Mann, Mann :P. Wenn ich mir hier die Werke aus meiner Vergangenheit ansehe (abgesehen von den HotSound Geschichten), kommt mir schon ein bischen das Grausen, aber es kommt auch ein bischen Nostalgie auf. Vor allem weil ich die Programme auch noch heute in der ein oder anderen Form noch benutze (auch wenn mir jedes mal ein kleiner Schauer den Rücken runterläuft, wenn ich an den Code dahinter denke) :P.
 
Zuletzt bearbeitet:
Zurück
Oben Unten