[AndroidSnippets] Kamerabilder schießen und speichern

Hallo,

in meiner Reihe AndroidSnippets werde ich euch nützliche Klassen zur Verfügung stellen, die euch euren Arbeitsalltag erleichtern werden als Entwickler.

Heute: Schnell ein Foto mit der Kamera schießen

Gefunden auf flickr.com, von  Dan H
Gefunden auf flickr.com, von Dan H

In vielen Apps braucht man die Möglichkeit Fotos zu schießen. Heute zeige ich euch, wie ihr das recht schnell implementieren könnt.

[AndroidSnippets] Kamerabilder schießen und speichern weiterlesen

Ein Pluginsystem mit Paketserver in PHP – Teil 3

Ein Pluginsystem mit Paketserver in PHP – Teil 3

Nachdem wir nun wissen, wie ein Plugin aufgebaut ist und wir wir es im Frontend verwenden, müssen wir uns mit der Frage beschäftigen, wie wir die Plugins im Backend administrieren.

Generell ist meine Überlegung, dass das ACP eine PHP Datei hat, die je nach übergebener ID aus dem Pluginordner die Backenddateien nachlädt.

Ein Beispiel: Im ACP gibt es eine Datei plugin_list.php.
Rufen wir diese Datei auf, so erscheint eine Liste mit Plugins, wie hier:

Pluginliste

Von hier aus, kann man die Plugins administrieren.
Dazu ruft man dann plugin_verwalten.php?appid=X auf, dann erscheint, je nach Plugin, die entsprechenden ACP Seite.

Um  die plugin_list.php anzuzeigen, ist nicht viel nötig.
Der nötige SQL Befehl lautet:

SELECT * FROM plugins ORDER BY id;

Geben wir die Ergebnisse einfach als eine normale Liste aus:


$query = mysql_query("SELECT * FROM plugins ORDER BY id;");

$AppsNum = mysql_num_rows();
 $AppsTd="";
 while ($AppsArray = mysql_fetch_object($query)) {
 $color ="red";

 if ($AppsArray->activate=="1" || $AppsArray->activate=="true") { $color = "lightgreen"; }
 $AppsTd .= '<tr style="background-color:'.$color.';"><td style="width:20%;">'.$AppsArray->name.'</td><td "width:5%;">'.$AppsArray->version.'</td><td "width:45%;">'.$AppsArray->desc.'</td><td "width:35%;"><a href="plugin_verwalten.php?appid='.$AppsArray->id.'">Administrieren</a></td></tr>';
 }

 echo 'Installierte Erweiterungen:<br><div class="cel" style="height:auto;">
 <table style="width:100%;"><tr style="border: 1px black solid;"><td>Name</td><td>Version</td><td>Beschreibung</td><td>Optionen</td></tr> '.$AppsTd.'</table></div><br /><br />';

 

Die plugin_verwalten.php ist recht einfach aufgebaut, sie prüft nur, ob die angegebene ID konform und in der Datenbank existent ist und includiert dann die hinterlegten Dateien:


<?php

 /*
 Checke die Paratemter in der GET
 */

 if (!isset($_GET['appid']) OR !is_numeric($_GET['appid'])){
 trigger_error("Die Variable \"appid\" ist entweder nicht übergeben worden oder entspricht nicht den Vorraussetzungen.",E_USER_ERROR);
 }

$appid = $_GET['appid'];

 /*
 Schauen wir mal nach der und laden alle Daten in ein array() ^^
 Und natürlich wider zählen
 */

 $query = mysql_query("SELECT * FROM plugins WHERE ID = ".$appid);

 $row = mysql_fetch_object($query);

 $num = mysql_num_rows();

 /*
 Wenn jetzt $num = 0 oder > 1 ist, dan stimmt was nicht
 */

 if ($num != 1) {
 trigger_error("Die ID ist nicht vorhanden und/oder mehrmals vergeben. Dies macht eine eindeutige Identifikation unmöglich.",E_USER_ERROR);
 }

 /*
 So, dann schauen wir mal OptionFile an und laden die Datei hier rein^^
 */
 define("apppath",$row->path);
 require_once(apppath."/cp/index.php");

 /*
 Für mich ist die Sache damit erledigt :)
 */

Okay, nun wissen wir, wie wir die Backenddateien verwalten.

Im nächsten Teil installieren wir die Plugins via einem Updateserver.

Zur Hauptseite

Ein Pluginsystem mit Paketserver in PHP – Teil 1

Ein PHP Plugin- und Paketsystem – Teil 1

Welcher PHP Programmierer möchte das nicht, ein Pluginsystem für seine Anwendung, welches in der Lage ist, Pakete von einem Server nachzuladen und schick zu installieren.
Ich wollte so etwas auch für meine Anwendung gFramework. Zwar hatte ich bereits vor 3 Jahren ein mal einen ähnlichen Code bereits geschrieben, doch toll und performant war dieser gar nicht.
In den folgenden Teilen dieses Tutorials möchte ich euch zeigen, wie Ihr euch so ein Pluginsystem baut und anschließend, wie Ihr ein Paketserver aufsetzt und eine automatische Installationsroutine in eure Anwendung einbaut.
Dafür werde ich das Know-How nutzen, welches ich mir im letzten halben Jahr für gFramework angegeignet habe. Die Gesamtentwicklungszeit des Systemes liegt „nur“ bei 6 bis 7 Stunden (für mich als Laie auf diesem Gebiet bis Dato.).
Ihr findet am Ende jedes Teiles den ganzen Code der im Teil behandelten Dateien. Wenn Ihr nicht alle Dateien kopieren wollt, so ladet euch das gFramework herunter. (Zusatz: Erscheinungstermin und weitere Details: s. http://bug.gvisions.de)

Der hier veröffentliche Quellcode kann unter den folgenden Bedingungen genutzt und veröffentlicht werden.

Was soll das System können?

Bevor wir uns um die Erstellung der Klasse kümmern, klären wir erst einmal, was die Klasse am Ende alles können soll:

  • generalle Pluginfunktionalität: d.h. Plugin durch URL Parameter aufrufen, auf Rechte prüfen und sichern, das ganze modular
  • Plugins in Datenbank verwalten
  • Plugin(de)installation
  • Plugin von Paketserver installieren

Fangen wir an mit der Plugindatenbank

Um die Plugins später in der Datenbank zu verwalten, müssen wir eine Tabelle anlegen, nennen wir diese ‚plugins‘.
Was für Felder brauchen wir in der Datenbank?

  • id int (99) auto_increment key – Hieran wird das Plugin erkannt
  • name varchar(200) – Dies ist der Name des Plugins
  • activate bool – Hier steht jeweils nur true oder false, jenachdem, ob das Plugin aktiv ist oder nicht
  • desc text – Hier soll der Entwickler eine kurze Beschreibung mitliefern, ggf. mit HilfeURL oder Screenshot
  • com_id varchar(200) – Diese ID setzt sich aus einem Präfix, den Herstellernamen und dem Pluginnamen zusammen (ähnlich wie bei Android), zB com.gvisions.framework oder com.mustermann.faq
  • version varchar(200) – Die aktuell installierte Version
  • path varchar(999) – Dies stellt den relativen Pfad zum Plugin auf dem Server dar
  • updateServer int(10) – Hier steht die ID des UpdateServer drinn, dazu kommen wir später noch.

Hier nun der SQL Code zur Datenbank:

CREATE TABLE IF NOT EXISTS `gframework_plugins` (
`id` int(99) NOT NULL AUTO_INCREMENT,
`name` varchar(200) NOT NULL DEFAULT “,
`activate` varchar(200) NOT NULL DEFAULT ‚true‘,
`desc` text NOT NULL,
`com_id` varchar(200) NOT NULL,
`version` varchar(20) NOT NULL,
`path` varchar(200) NOT NULL COMMENT ‚von root an zB root./apps/…/‘,
`updateServer` int(10) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=37 ;

Damit wir einheitlich arbeiten, gebe ich euch nun eine Ordnerstruktur vor, mit welcher ich arbeite.
Ihr könnt die gesamte Klasse dann auf eure Struktur anpassen, wenn dies erforderlich ist.

/ – Dies ist der Root des Projektes
/apps – Hier liegen alle Plugins
/apps/com.gvisions.framework – Die Pluginordner sind nach dessen comid benannt, hierdurch wird die Wahrscheinlichkeit = 0, dass ein Pluginordner sich doppelt, denn bei der Installation wird geprüft, ob die comid schon registriert ist.
/core – Hier liegen die Systemdateien
/core/classes – Und hier die Klasse, indem Fall auch die Klasse gPlugin und die Klasse gInstall, welche wir brauchen

Kommen wir zum Aufruf des Plugins…

…bevor wir zum Anfang der Klasse kommen.
Um ein Plugin aufzurufen, übergeben wir den Parameter $_GET[‚app‘] mit der PluginID oder den Parameter $_GET[‚app_comid‘] mit der comID.
Wir schauen dann, mithilfe SQL, ob diese AppID bzw. die comID existent ist und aktiv ist.
Falls beide Abfragen true ergeben binden wir das Plugin ein, ansonten schalten wir eine 404 Seite:
Datei: /index.php


<?php

/**
* gFramework is a little framework for Scripts by gVisions.
*
*
* PHP 5
*
* LICENSE: Creative Commong NC-BY-SA 3.0 with additional legalcode (link above)
*
* @package    com.gvisions.framework
* @author     Alexander Grüßung <me at gvisions dot de>
* @copyright  2011 Alexander Grüßung
* @license    http://gvisions.de/rechte.html CC NC-BY-SA 3.0 with additional legalcode
* @version    0.5
* @link       http://gvisions.de
*/

/*
eine AppID wird immer bevorzugt, falls parralel eine app_comid angeben ist!
*/

$appid = "";
$app_comid = "";
if (isset($_GET['app']) ){
$appid = $_GET['app'];
}
if (isset($_GET['app_comid'])) {
$app_comid = $_GET['app_comid'];
}
if (empty($appid) AND empty($app_comid)) {

/*
Baue DB Verb. auf und schaue, welche App als aller erstes in der DB steht,  laden wir dann einfach diese. Der Nutzer wird darauf per trigger_error(); hingewisen!
*/

$db = new db();
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE `id` != '1' ORDER BY id ASC LIMIT 0,1");
$app = $db->fetch();
if ($app->activate != "true" AND $app->activate != "1") {
require_once("apps/com.gvisions.framework/pluginnotfound.php");
die();
}
require_once($app->path."/index.php");

/*
So, dann hoffen wir mal, es war richtig.
*/

die();

}

/*
Gibt es diese Applikation denn in unserer Datenbank ?
Baue DB Verb. dafür auf:
*/

$db = new db();

/*
Suche nun in der DB nach der Applikation.
Eigentlich sollte ja nur eine Übereinstimmung vorhanden sein.
*/

if (!empty($appid)) {
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE id = ".$appid."");
}
elseif (!empty($app_comid)) {
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE `com_id` = '".$app_comid."'");
}
else
{
trigger_error("Interner Fehler bei appid und app_comid.",E_USER_ERROR);
}
/*
So, dann mal alles in einem array speichern
*/
$row = $db->fetch();

/*
Es gibt eine Übereinstimmung, gut, dann binden wir das Teil mal ein.
Und überlassen wir der Applikation den Rest.
*/

if ($row->activate != "true" AND $row->activate != "1")
{
require_once("apps/com.gvisions.framework/pluginnotfound.php"); //404 Seite im Hauptplugin, Pfad kann natürlich angepasst werden
die();
}
if ($num==1){
require_once($row->path."/index.php");
}

(Ein kurzer Hinweis: Ich arbeite mit einer Datenbankklasse, ihr könnt natürlich die normalen Befehle, wie mysql_connect(); mysql_query(); und andere, nutzen.)

Wie Ihr seht ist das einbinden relativ einfach, sieht mehr aus, als es ist, durch die vielen Kommentare für euch 😉
Auch seht Ihr, dass beim Aufruf keine gPlugin-Klasse aufgerufen wird, wieso? Weil die notwendigen Daten _alle_ In der Datenbank stehen, wieso dann extra Laufzeit erzeugen und über eine Klasse gehen.
Soweit wäre das Tutorial ja eigentlich zu Ende, schließlich können wir nun Plugins laden…nur ist das natürlich nicht alles, was wir wollen.

Wir wir nun die Plugins intern verwalten, das sehen wir im nächsten Teil des Tutorials!
Zur Hauptseite

Über Feedback würde ich mich natürlich freuen.