Professional Documents
Culture Documents
PROIECT DE DIPLOMĂ
Chişinău - 2017
4
Cuprins
Capitolul I Cadrul teoretic.....................................................................................6
1.1 Introducere în .NET 6
1.2 Limbajul Java 7
1.3 Introducere în Android Studio 9
1.4 Cerințe de sistem 9
1.5 Wi-fi. Noțiuni generale 10
1.6 Istoria supravegherii video 11
Capitolul II Elaborarea proiectului.................................................................13
2.1 Descrierea aplicației 13
2.2 Descrierea aplicației la nivel de utilizator 13
2.3 Aplicabilitatea aplicației 15
2.4 Compararea cu alte dispozitive de supraveghere video 15
Capitolul III Realizarea proiectului.................................................................16
3.1 Descrierea aplicației la nivel de programator 16
Capitolul IV Calculul economic.......................................................................32
4.1 Costul de producție 34
4.2 Consumuri directe privind retribuirea muncii 35
4.3 Consumuri indirecte de producție 37
4.4 Costul de producție al proiectului 37
4.5 Prognozarea rezultatelor financiare 38
4.6 Strategia de implimentare a proiectului 40
Capitolul V Securitate și sănătate în muncă...................................................41
5.1 Cerințe de securitate și sănătate pentru programatori 41
5.2 Riscurile profesionale care pot aparea pe parcursul executării sarcinii de muncă 43
5.3 Cerințe de microclimat la locul de muncă 44
5.4 Echipamentul de protecție utilizat la locul de muncă 45
Concluzii.............................................................................................................46
ANEXE...............................................................................................................49
5
Capitolul I Cadrul teoretic
6
- Platforma comună de executare a programelor numită Common Language Runtime
- (CLR), utilizată de toate cele 4 limbaje. CTS face parte din CLR.
- Ansamblul de biblioteci necesare în realizarea aplicaţiilor desktop sau Web, numit
- Framework Class Library (FCL).
Platforma .NET
Platforma .NET (.NET Framework) este un nivel software plasat peste sistemul de ws şi
conţine două parţi principale: unitatea de execuţie a programelor .NET (Common Language
Runtime – CLR) şi biblioteca de clase .NET (Framework Class Library – FCL). Biblioteca FCL
este compusă din biblioteca de baza (Framework Base Classes) care conţine din tipuri (clase)
fundamentale, clase pentru dezvoltarea aplicaţiilor de baze de date (ADO.NET, SQL, XML,
etc.), clase pentru de zvoltarea aplicaţiilor complexe (Windows Forms), clase pentru dezvoltarea
aplicaţiilor distribuite în Internet (Web Forms, Web Services).
7
- Java Platform, Standard Edition (Java SE) — pentru sisteme gen workstation, este ceea
ce se găsește pe PC-uri;
- Java Platform, Enterprise Edition (Java EE) — pentru sisteme de calcul mari, eventual
distribuite.
Kit Java Development (JDK) este o implementare de oricare dintre Java SE, Java EE sau
Java ME platforme lansat de Oracle Corporation, sub forma unui produs binar care vizează
dezvoltatorii Java pe Solaris, Linux, Mac OS X sau Windows. JDK include un JVM privat și alte
câteva resurse pentru a termina rețeta la o aplicație Java. De la introducerea platformei Java, a
fost, de departe, Software Development Kit mai utilizate pe scară largă (SDK).
JDK are ca componentele sale principale o colecție de instrumente de programare,
inclusiv:
- appletviewer - acest instrument poate fi folosit pentru a rula și de depanare Java applet-
uri fără un browser web,
- idlj - compilatorul IDL-to-Java. Acest utilitar generează legături Java dintr-un anumit
fișier Java IDL;
- jabswitch - Acces Podul Java. Expune tehnologii de asistență pe sistemele Microsoft
Windows;
- java - incarcator pentru aplicații Java. Acest instrument este un interpret și poate
interpreta fișierele de clasă generate de compilator javac;
- javac - compilatorul Java, care convertește codul sursă în Java bytecode;
- javadoc - generatorul de documentare, care generează automat documentația de
comentarii cod sursă;
- jar - arhivator, ce pachete bibliotecile de clasă legate într-un singur fișier JAR. Acest
instrument de asemenea, vă ajută să gestionați fișiere JAR;
- javafxpackager - instrument pentru a împacheta și să semneze aplicații JavaFX;
- javaws - lansatorul Java Web Start pentru aplicații JNLP;
- JConsole - Java Monitorizare și Management Console;
- JDB – debugger;
- pack200 - instrument de compresie JAR;
- policytool - crearea de politici și instrument de management, care poate determina
politica de execuție Java, specificând care sunt disponibile permisiuni pentru codul din
diverse surse;
8
- VisualVM - instrument vizual integrare mai multe comenzi de linie de instrumente JDK
și [clarificare necesare] performanță și de memorie profilare capacități ușoare;
- wsimport - generează portabile artefacte JAX-WS pentru invocarea unui serviciu web.
9
1.5 Wi-fi. Noțiuni generale
Wi-Fi este numele comercial pentru tehnologiile construite pe baza standardelor de
comunicație din familia IEEE 802.11 utilizate pentru realizarea de rețele locale de comunicație
(LAN) fără fir (wireless, WLAN) la viteze echivalente cu cele ale rețelelor cu fir electric de
tip Ethernet. Suportul pentru Wi-Fi este furnizat de diferite dispozitive hardware, și de aproape
toate sistemele de operaremoderne pentru calculatoarele personale (PC), rutere, telefoane
mobile și cele mai avansate console de jocuri. Standardul IEEE 802.11 descrie protocoale de
comunicație aflate la nivelul gazdă-rețea al Modelului TCP/IP, respectiv la nivelurile fizic și
legătură de date ale Modelului OSI. Aceasta înseamnă că implementările IEEE 802.11 trebuie să
primească pachete de la protocoalele de la nivelul rețea (IP) și să se ocupe cu transmiterea lor,
evitând eventualele coliziuni cu alte stații care doresc să transmită.
802.11 face parte dintr-o familie de standarde pentru comunicațiile în rețele locale,
elaborate de IEEE, și din care mai fac parte standarde pentru alte feluri de rețele, inclusiv
standardul 802.3, pentru Ethernet. Cum Ethernet era din ce în ce mai popular la jumătatea anilor
1990, s-au depus eforturi ca noul standard să fie compatibil cu acesta, din punctul de vedere al
transmiterii pachetelor.
Standardul a fost elaborat de IEEE în anii 1990, prima versiune a lui fiind definitivată în
1997. Acea versiune nu mai este folosită de implementatori, versiunile mai noi și îmbunătățite
802.11a/b/g fiind publicate între 1999 și 2001. Din 2004 se lucrează la o nouă versiune, intitulată
802.11n și care, deși nu a fost definitivată, este deja implementată de unii furnizori de
echipamente.
Din punct de vedere al securității, IEEE și Wi-Fi Alliance recomandă utilizarea
standardului de securitate 802.11i, respectiv a schemei WPA2. Alte tehnici simple de control al
accesului la o rețea 802.11 sunt considerate nesigure, cum este și schema WEP, dependentă de un
algoritm de criptare simetrică, RC4, nesigur.
Limitările standardului provin din mediul fără fir folosit, care face ca rețelele IEEE
802.11 să fie mai lente decât cele cablate, de exemplu Ethernet, dar și din folosirea benzii de
frecvență de 2,4 GHz, împărțită în 12 canale care se suprapun parțial două câte două. Cu toate
acestea au apărut și unele tehnologii care permit legături fără fir bazate pe standardul 802.11
între două puncte fixe aflate la distanțe de ordinul sutelor de kilometri.
10
O limitare importantă a rețelelor Wi-Fi o constituie aria de acoperire. Ea depinde mult de
capabilitățile antenelor dispozitivelor și de topografia particulară a zonei pe care urmărește
rețeaua să o acopere.
Plantele absorb radiațiile electromagnetice, și astfel instalarea unei rețele într-o zonă
împădurită (cum ar fi un parc) limitează aria de acoperire a acesteia.
Pereții de beton reflectă puternic undele radio, instalarea unei rețele într-o clădire
aducând astfel limitarea numărului de camere ce poate fi acoperit de o singură celulă. În
interiorul clădirilor, un punct de acces cu o antenă de dimensiuni mici și un preț accesibil poate
acoperi o rază de aproximativ 32 m, iar în exterior, același punct de acces poate ajunge la 95 m.
Aria de acoperire poate fi și mai restrânsă în cazul folosirii benzii de 5 GHz în locul celei
de 2,4 GHz (mai zgomotoasă, dar în care se poate acoperi o arie mai mare).
Durata acumulatorilor (bateriilor) stațiilor mobile reprezintă și ea o limitare.
Acumulatorul unui PDA, care în mod normal ar funcționa mai multe zile, se poate descărca în
câteva ore dacă i se lasă radioul Wi-Fi pornit. Laptop-urile dotate cu adaptor IEEE-802.11 sunt
prevăzute și cu un buton de oprire a emițătorului radio Wi-Fi, pentru a evita descărcarea
acumulatorului atunci când nu se folosește rețeaua fără fir.
Supravegherea video este unul dintre elementele care ne insoteste zi de zi si este prezenta in din
ce in ce mai multe locuri. Ce stim insa despre istoria ei?
Desi exista destul de multe povesti si speculatii despre istoria supravegherii video, se pare
ca adevarul se regaseste undeva in anul 1933, cand prima camera de supraveghere si-a facut
aparitia ca rod al imaginatiei domnului Norbury din Marea Britanie. Evident, camera nu era
asemanatoare cu ceea ce exista astazi. Camera lui Norbury era formata dintr-o camera foto cu
fata in jos, care supraveghea un cuibar de gaini. Cu ajutorul unor saci, a unui tub de metal si a
unui fir pozitionat la usa cuibarului pentru a crea zgomot, camera se declansa in asa fel incat,
daca cineva incerca sa fure oua, putea fi prins mult mai usor.Se pare ca tot sistemul a functionat,
iar cel care ii fura ouale din cuibar a fost prins.
De la sistemul inventat de Norbury pana la ceea ce gasim astazi peste tot nu mai este o
cale foarte lunga. Dezvoltarea industriei de supraveghere a luat o ampoare foarte mare si a ajuns,
11
pentru inceput sa fie preluata de institutiile precum cele guvernamentale, ale politiei, Fbi-ului sau
SRI-ului.
Astazi, camerele de supraveghere sunt aproape oriunde. Le poti gasi in orice cartier, pe
orice strada si in aproape orice supermarket, scoala, spital si alte institutii de acest fel.
Diversitatea camerelor este si ea foarte mare, existand solutii care pot fi eficiente pentru orice
situatie. Poti alege camere de supraveghere in functie de design, de culoare, de configuratie sau
de forma si marime.
Astazi, inregistrarea se face pe DVR pentru camerele analog si pe NVR pentru cele IP.
Spatiul de stocare nu mai este o problema, existand HDD-uri care pot pastra cu usurinta cateva
luni de filmari. Sistemele de supraveghere de astazi pot fi urmarite pe internet, de oriunde din
lume iar calitatea imaginilor a crescut semnificativ. Asadar, ne putem bucura de o perioada in
care totul ne este la indemana iar siguranta este din ce in ce mai mare.
12
Capitolul II Elaborarea proiectului
2.1 Descrierea aplicației
Supravegherea video este un aspect incontestabil al societății moderne care din ce în ce
mai mult i-a amploare. Oportunitatea de a-i urmări pe oameni fără de a fi observați reprezintă, în
cele din urmă un factor de putere.Proiectul meu constă în crearea unei aplicații care ne v-a
permite supravegherea video de pe dispozitivul mobil. Pentru aceasta eu voi avea nevoie de 2
dispozitive: un dispozitiv care v-a capta imaginile iar altul de pe care le vom putea vedea. Aceste
dispositive sunt 2 smartphoane pe sistemul de operare android.
Aplicația o voi crea în mediul de dezvoltare Android Studio. Ea v-a avea o interfață
simplă formată din un button cu numele „client” și altul cu numele „server” și un element numit
“ImageView” și care ne permite afișarea pe ecran a secvențelor video pe care le v-a face camera
smartphonului.
Acest lucru v-a fi poibil doar daca dipozitivele au conexiune la internet. Apăsînd pe
buttonul „client” noi vom introduce niște numere care vor reprezenta ip-ul serverului. Acest ip
este afișat dacă apăsăm pe buttonul “server”. După introducerea ip-ului corect pe telefon vor
apărea imaginile care le captează celălalt telefon.
13
Interfața “ServerActivity” destinată pentru receptionarea imaginilor (Vezi fig. 2.2)
14
2.3 Aplicabilitatea aplicației
Ca utilizator, aplicația v-a avea o interfață simplă dar cu o aplicabilitate mare. După
dorință, utilizatorul o v-a putea folosi nu doar ca sistem pentru supraveghere video, dar și ca
transmitere a imaginilor la distanță. De ex. dacă avem un quadcopter, putem atașa de el un
dispozitiv cu aplicația dată care ne v-a transmite imagini de sus, astfel fiind posibilă vizualizarea
unor peisaje frumoase. Aplicabilitatea aplicației este mare și diferită. Totul depinde de utilizator.
El o poate folosi pentru cele spuse mai sus dar și pentru distracție. Închipuiți-vă ca un grup de
persone transmit live ceva interesant unei personae care nu a putut fi cu ei. În cadrul colegiului,
liceului, școlii la fel îi găsim un loc aplicației date. Directorul poate veghea activitatea elevilor
fără de a umbla prin cabinete iar elevii se vor distra la pauze fără de a cheltui bani din cont sau
traffic de internet. Este nevoie doar de wi-fi și android.
15
Capitolul III Realizarea proiectului
3.1 Descrierea aplicației la nivel de programator
Interfața aplicației „StartActivity” (Vezi fig. 3.1)
16
setContentView(R.layout.activity_start);
final StartActivity me = this;
Button server = (Button) findViewById(R.id.buttonServer);
server.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(me, ServerActivity.class);
startActivity(intent);
}
});
Button client = (Button) findViewById(R.id.buttonClient);
client.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
AlertDialog.Builder builder = new AlertDialog.Builder(me);
builder.setTitle("Server IP");
final EditText input = new EditText(me);
input.setInputType(InputType.TYPE_CLASS_TEXT);
builder.setView(input);
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
String ip = input.getText().toString();
dialog.cancel();
Intent intent = new Intent(me, ClientActivity.class);
intent.putExtra("server", ip);
startActivity(intent);
}
});
builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
builder.show();
}
17
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_start, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
18
Interfața aplicației „activity_client” este afișată în figura .3.2.
19
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class ClientActivity extends ActionBarActivity {
private SurfaceView preview;
private SurfaceHolder previewHolder;
private ClientServer mServer;
private MediaRecorder mRecorder;
private Camera mCamera;
private boolean mPreviewRunning = false;
private String mIp = "";
private String serverIp = null;
private ScheduledFuture mAck;
@Override
protected void onStop() {
super.onStop();
if (mAck != null) {
mAck.cancel(false);
mAck = null;
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_client);
final ClientActivity me = this;
Intent startIntent = getIntent();
serverIp = startIntent.getStringExtra("server");
TextView clientIp = (TextView) findViewById(R.id.clientIpTextView);
mIp = MyTools.wifiIpAddress(me);
clientIp.setText("IP: " + mIp);
Log.e("", "Begin server");
mServer = new ClientServer(serverIp);
try {
mServer.start();
20
} catch (IOException e) {
e.printStackTrace();
}
Log.e("", "End server");
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
mAck = scheduler.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
mServer.sendAck(mIp);
}
}, 3, 1, TimeUnit.SECONDS);
preview = (SurfaceView) findViewById(R.id.clientSurface);
previewHolder = preview.getHolder();
previewHolder.addCallback(new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder holder) {
Log.e("", "Begin surfaceCreated");
mCamera = Camera.open();
mCamera.setDisplayOrientation(90);
Log.e("", "End surfaceCreated");
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
Log.e("", "Begin SurfaceChange");
mRecorder.reset();
mRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
mRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
mRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.MPEG_4_SP);
//mRecorder.setOutputFile("/sdcard/videotest2.mp4");
mRecorder.setVideoFrameRate(30);
mRecorder.setPreviewDisplay(previewHolder.getSurface());
try {
mRecorder.prepare();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
21
}
if (mPreviewRunning)
mCamera.stopPreview();
Camera.Parameters p = mCamera.getParameters();
// p.setPreviewSize(width, height);
mCamera.setParameters(p);
try {
mCamera.setPreviewDisplay(holder);
} catch (IOException e) {
e.printStackTrace();
}
mCamera.setPreviewCallback(new Camera.PreviewCallback() {
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
Log.e("", String.format("onPreviewFrame pass %d bytes", data.length));
Camera.Parameters p = mCamera.getParameters();
Camera.Size size = p.getPreviewSize();
YuvImage yuvimage=new YuvImage(data, ImageFormat.NV21, size.width,
size.height,null);
ByteArrayOutputStream baos=new ByteArrayOutputStream();
yuvimage.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, baos);
if (mServer != null) {
mServer.setImage(baos);
}
}
});
mCamera.startPreview();
mPreviewRunning = true;
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.e("", "Begin surfaceDestroyed");
mCamera.stopPreview();
mPreviewRunning = false;
}
});
22
previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
23
Listingul programului „ServerActivity”. Aici are loc definirea ip-ului și primirea
imaginilor de la client prin wi-fi.
package com.example.mozg.video1;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.Image;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.Spinner;
import android.widget.TextView;
import com.turbomanage.httpclient.HttpResponse;
import com.turbomanage.httpclient.ParameterMap;
import com.turbomanage.httpclient.android.AndroidHttpClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class ServerActivity extends ActionBarActivity {
private Spinner mSpinner;
private ServerServer mServer;
private String currentIp = null;
private ImageView mClientImage;
private boolean getImageRunning = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_server);
final ServerActivity me = this;
TextView ipView = (TextView) findViewById(R.id.serverIpTextView);
String mIp = MyTools.wifiIpAddress(me);
ipView.setText("IP: " + mIp);
24
Log.e("", "Begin server");
mServer = new ServerServer(me);
try {
mServer.start();
} catch (IOException e) {
e.printStackTrace();
}
Log.e("", "End server");
mClientImage = (ImageView) findViewById(R.id.clientImageView);
mClientImage.setRotation(90);
mSpinner = (Spinner) findViewById(R.id.clientsSpinner);
mSpinner.setAdapter(mServer.adapter);
mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
currentIp = mServer.clients.get(position);
if (!getImageRunning) getNewImage();
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
currentIp = null;
}
});
}
private void getNewImage() {
if (currentIp != null) {
new Thread(new Runnable(){
@Override
public void run() {
getImageRunning = true;
try {
AndroidHttpClient httpClient = new AndroidHttpClient(String.format("http://
%s:8080", currentIp));
ParameterMap params = httpClient.newParams();
HttpResponse httpResponse = httpClient.get("/stream.jpg", params);
25
if (httpResponse != null) {
String response = httpResponse.getBodyAsString();
final Bitmap bmp = BitmapFactory.decodeByteArray(httpResponse.getBody(),
0, httpResponse.getBody().length);
if (bmp == null) {
Log.e("", String.format("onPreviewFrame bmp is null!"));
} else {
runOnUiThread(new Runnable() {
@Override
public void run() {
Log.e("", String.format("onPreviewFrame bmp width=%dx%d",
bmp.getWidth(), bmp.getHeight()));
mClientImage.setImageBitmap(bmp);
Log.e("", String.format("onPreviewFrame bmp set end!"));
}
});
}
//Log.e("", String.format("response %s", response));
} else {
Log.e("", String.format("response is null"));
}
} catch (Exception e) {
e.printStackTrace();
}
getImageRunning = false;
getNewImage();
}
}).start();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_server, menu);
return true;
}
26
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
27
<activity
android:name=".ServerActivity"
android:label="@string/title_activity_server"
android:parentActivityName=".MainActivity" >
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value="com.example.mozg.video1.StartActivity" />
</activity>
<activity
android:name=".ClientActivity"
android:label="@string/title_activity_client"
android:parentActivityName=".MainActivity" >
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value="com.example.mozg.video1.StartActivity" />
</activity>
<activity
android:name=".StartActivity"
android:label="@string/title_activity_start" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
28
import java.io.InputStream;
import java.util.Map;
import java.util.logging.Logger;
import fi.iki.elonen.ServerRunner;
public class HelloServer extends fi.iki.elonen.NanoHTTPD {
private static final Logger LOG = Logger.getLogger(HelloServer.class.getName());
public HelloServer() {
super(8080);
}
private ByteArrayInputStream inputStream;
public void setOutStream(ByteArrayOutputStream out) {
inputStream = new ByteArrayInputStream(out.toByteArray());
}
public Response serve(IHTTPSession session) {
Method method = session.getMethod();
String uri = session.getUri();
ServerServer.LOG.info("ServerServer> " + method + " '" + uri + "' ");
if (uri.contains("register.html")) {
ServerServer.LOG.info("ServerServer> Got new register");
Map<String, String> params = session.getHeaders();
//Map<String, String> params = session.getParms();
Iterator it = params.entrySet().iterator();
String ip = null;
while (it.hasNext()) {
Map.Entry pair = (Map.Entry)it.next();
if (pair.getKey().equals("http-client-ip")) {
ip = (String) pair.getValue();
}
it.remove();
}
if (ip != null) {
if(!clients.contains(ip)) {
ServerServer.LOG.info("ServerServer> Got new ip: '" + ip + "' ");
clients.add(ip);
29
adapter.notifyDataSetChanged();
}
}
}
String msg = "ok";
return newFixedLengthResponse(msg);
}
}
@Override
public Response serve(IHTTPSession session) {
Method method = session.getMethod();
String uri = session.getUri();
HelloServer.LOG.info(method + " '" + uri + "' ");
if(uri.contains(".jpg") && inputStream != null){
return newFixedLengthResponse(Response.Status.OK, "image/jpeg",
inputStream, inputStream.available());
} else {
String msg = "<html><body><h1>Hello server</h1>\n";
Map<String, String> parms = session.getParms();
if (parms.get("username") == null) {
msg += "<form action='?' method='get'>\n" + " <p>Your name: <input
type='text' name='username'></p>\n" + "</form>\n";
} else {
msg += "<p>Hello, " + parms.get("username") + "!</p>";
}
msg += "</body></html>\n";
return newFixedLengthResponse(msg);
}
}
}
Listingul programului „MyTools”. Aici are loc declararea parametrilor pentru ca aplicația
să primească și să transmită date prin wi-fi.
import android.content.Context;
import android.net.wifi.WifiManager;
30
import android.util.Log;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteOrder;
public class MyTools {
public static String wifiIpAddress(Context context) {
WifiManager wifiManager = (WifiManager)
context.getSystemService(Context.WIFI_SERVICE);
int ipAddress = wifiManager.getConnectionInfo().getIpAddress();
if (ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)) {
ipAddress = Integer.reverseBytes(ipAddress);
}
byte[] ipByteArray = BigInteger.valueOf(ipAddress).toByteArray();
String ipAddressString;
try {
ipAddressString = InetAddress.getByAddress(ipByteArray).getHostAddress();
} catch (UnknownHostException ex) {
Log.e("WIFIIP", "Unable to get host address.");
ipAddressString = null;
}
return ipAddressString;
}
}
Codul ce ține de designul aplicației este afișat în anexa .
31
Capitolul IV Calculul economic
Date generale
Sistemul economic se află într – o continuă transformare, calitativă și cantitativă.
Modificarea sistemului economic în conconrdanță cu piața este o sarcină de bază a economiei
naţionale.
Științele economice au ca obiect de studiu gestiunea eficientă a resurselor fmanciare și
umane (limitate). Variatatea de resurse prezintă dobânda functionalității interacţiunilor dintre
consumator și producător. Funcționarea armonioasă a economiei naționale depinde de
funcționarea întreprinderilor, care compun un sitem de mijloace ciculante și mijloacele fixe.
Ansablu de activități economice cuprind operaţiuni în urma cărora piața se va diversifica spre
necesitățile consumatorilor finali.
Acest proiect este destinat calculului ce ar oferi crearea unor programe de securitate , în
domeniul rețeleor. Un domeniu destul vast ales concret și profitabil. Planul are ca scop prestarea
serviciilor absolut necesare cum ar fi scanarea porturilor un TCP server. Acesta este primul pas
de a ne focusa. Aceste metode pot fi folosite pașnic, pentru a verifica totalitatea sitemelor pe
vulnerabilitate, astfel utilizatorii de rețea pot păși peste acest focus, deci, se poate de obținut
profit prin astfel de metode. Planul oferă clienților flexibilitatea în domeniul securități incluzînd
posibilitatea de – a exclude eventualele atacuri. Venitul este obținut în dependență de cheltuielile
efectuate. Planul dat poate avea о eficiență economică considerabilă datorită cererii pe piață și
necesității de către consumatori pentru protecția rețeleor.
În etapele procesului de elaborare a planului se estimează următoarele aspecte:
- Evaluarea mediului intern şi extern a proiectului;
- Analiza concurenţilor;
- Determinarea necesarului de resurse capitale, materiale şi umane;
- Calcularea indicatorilor economici;
- Elaborarea strategiei de implimentare a proiectului.
Pentru evaluarea mediului intern şi extern a proiectului în detaliu, se va aplica analiza
SWOT. Analiza mediului intern se bazează pe totalitatea factorilor care au o influenţă
determinată. Aceşti factori se clasifică în două grupe:
1 Punctele forte se referă la avantajele pe care le are proiectul şi care pot susţine necesarul
afacerii;
2 Punctele slabe se referă la acele elemente ale mediului intern din proiect care implică
dezavantaje;
32
Analiza mediului extern identifică şi evaluiază factorii din exterior, care influenţează
asupra elaborării proiectului. Aceşti factori se clasifică în două grupe:
1 Oportunităţile sunt factorii care oferă sau va oferi posibilităţi proiectului de a se elabora;
2 Pericolele (riscurilele) sunt factorii care crează obstacole proiectului de a se elabora.
Analiza SWOT Tabelul 4.1
Punctele forte Punctele slabe
1 Investiții minime; 1 Descărcarea bateriei dispozitivelor;
2 Interacțiunea dispozitivelor depinde de
2 Simplitate în utilizare;
distanța dintre ele;
3 Posibilitatea de vizualizare directă a datelor 3 Lipsa de actualizare automată.
Oportunităţile Pericolele (riscurilele)
33
Utilajele consumate vor transmite direct valoarea sa, cît și conținutul lor asupra noului
proiectului integral sau parțial.
Utilajele necesare sunt reprezentate în tabelul 4.3
Materialele pentru proiect Tabelul 4.3
Nr. Denumirea Unitatea de Preț, Valoarea,
Tipul Cantitatea
d/o Utilajelor măsură lei lei
Telefon pe sistema Huawei
1 OBIECT 1 2000 2000,00
android ascend p6
2 Calculator Asus OBIECT 1 3000 3000,00
3 Cablu USB Orice tip OBIECT 1 50 50,00
Telefon pe sistema Huawei
4 OBIECT 1 4000 4000,00
android ascend p7
Total 9050,00
34
pentru
zile
operație, lei
Muncă simplă
Instalarea
conform 1 1,26 7,30 7,30
softului
specialităţii
Muncă
deosebit de
Programarea
complicată 15 2,69 234,03 3150,45
codului 5,80
conform
specialităţii
Muncă
Instalarea pe deosebit de
telefon si complicată 2 2,69 31,20 62,40
tableta conform
specialităţii
Total 18 – 3220,15
4.2.1.2 În cazul îndeplinirii planului, determinăm prima care, constituie 25% din salariu direct
al muncitorului
35
4.2.1.5 Se determină contribuția de asistență medicală în proporție de (9%) (întreprinderea achită
4,5% din Fr.m. lunar calculat și 4,5% suportă angajatul) conform relației:
4.2.2 Se determină suma consumurilor directe, pentru aplicaţia proiectului, conform relaţiei:
36
4.4 Costul de producție al proiectului
4.4.1 Costul producţiei globale se determină prin însumarea consumurilor directe şi indirecte
pentru proiect:
4.4.3 Costul total se determină prin însumarea costulului producţiei globale cu cheltuielile de
marketing:
37
Rezultatele financiare Tabelul 4.7
Consumuri directe şi indirecte ce constituie costul dispozitivului
Nr.d/o Valuarea
Articole
cheltuielilor, lei
1 Consumuri directe de producție
1.1 Stocuri de utilaje ,00
1.2 Stocuri de semifabricate 0
1.3 Cheltuieli de energie electrică 57,10
1.4 Cheltuieli pentru reţeaua internet 100,00
1.5 Cheltuieli directe de producție
2 Cosumuri directe privind retribuirea muncii
2.1 Fondul de retribuire a muncii
2.2 Contribuţiile în Fondul Social
2.3 Contribuţiile de Asistență Medicală
38
5.3 Rentabilitatea
39
Capitolul V Securitate și sănătate în muncă
5.1 Cerințe de securitate și sănătate pentru programatori
Informarea şi instruirea lucrătorilor
Angajatorul va asigura informarea lucrătorilor asupra tuturor aspectelor de securitate şi
sănătate în muncă derivate din cerinţele desfăşurării activităţilor, precum şi asupra măsurilor
aplicabile la locul de muncă.
Lucrătorii vor fi instruiţi în utilizarea echipamentelor de calcul si a mobilierului specific
de birou înainte de începerea activităţii şi ori de câte ori se modifică organizarea sau dotarea
locurilor de muncă.
Lucrătorii vor fi instruiţi special asupra necesităţii amenajării ergonomice a locului de
muncă şi asupra poziţiilor / mişcărilor / deplasărilor corecte pe care trebuie să le adopte în timpul
lucrului.
Organizarea activităţii
1) În cazul lucrului continuu în faţa ecranului, trebuie prevăzute pauze corespunzătoare şi
alternarea;
2) Durata reală a lucrului în faţa ecranului trebuie să fie mai mică de 6 ore pe zi;
3) Sarcinile lucrătorilor trebuie diversificate.
4) Lucrătorii trebuie să decidă ordinea în care îşi execută sarcinile;
5) Lucrătorii nu trebuie să simtă o presiune excesivă în îndeplinirea sarcinilor de lucru sau în
realizarea termenelor finale;
6) Angajatorul asigură informarea, instruirea şi consultarea corespunzătoare înainte de
înfiinţarea, menţinerea sau îmbunătăţirea locurilor de muncă care implică utilizarea
computerelor.
Amenajarea locului de muncă
Amenajarea locului de muncă trebuie astfel realizată încât să ofere utilizatorilor confort şi
libertate de mişcare şi să diminueze în măsură maxim posibilă riscurile de natură vizuală,
mentală şi posturală.
Posturile de muncă trebuie concepute şi amenajate astfel încât să permită unor persoane
diferite să realizeze o gamă diversă de sarcini de muncă, într-un mod confortabil şi eficient, la
nivelul de performanţe cerut.
Locul de muncă trebuie să permită o bună corelare între caracteristicile
antropofuncţionale ale utilizatorilor şi munca lor prin asigurarea posibilităţilor de reglare a
diferitelor elemente componente ale acestuia, (fig. 5.l).
40
Fig. 5.1 – Scaun reglabil
Utilizatorii trebuie să aibă posibilităţi de modificare a poziţiei de lucru, în timpul
activităţii.
Înălţimea tastaturii trebuie să asigure în timpul utilizării un unghi între braţ şi antebraţ de
minimum 90°.
În poziţie aşezat, distanţa dintre planul de lucru şi suprafaţa de şedere trebuie să fie
cuprinsă între 200 şi 260 mm.
Ecranul, suportul de documente şi tastatura trebuie amplasate la distanţe aproximativ
egale faţă de ochii utilizatorului, respectiv 600 ±150 mm.
Ecranul, suportul de documente şi tastatura trebuie amplasate la distanţe aproximativ
egale faţă de ochii utilizatorului, respectiv 600 ±150 mm.
41
Mesele nereglabile vor avea o înălţime de 730 ± 10 mm. în condiţiile în care
echipamentul de calcul este utilizat succesiv de mai multe persoane, mesele vor fi reglabile în
înălţime, cu posibilităţi de reglare între 650 şi 740 mm. Adâncimea minimă a spaţiului liber
disponibil pentru membrele inferioare sub planul de lucru va fi de 700 mm.
Materialul din care este confecţionat planul de lucru nu trebuie să fie rece la atingere sau
să antreneze o conductivitate excesivă a căldurii către corpul utilizatorului.
42
5.3 Cerințe de microclimat la locul de muncă
Iluminat
Iluminatul încăperilor de lucru va fi proiectat în funcţie de caracteristicile sarcinii de
muncă şi cerinţele vizuale ale utilizatorilor, astfel încât să se asigure niveluri de iluminare şi un
contrast adecvat între ecran şi mediu, pentru obţinerea unei performanţe vizuale ridicate.
Ferestrele vor fi prevăzute cu un sistem corespunzător de protecţie reglabil.
Iluminatul în încăpere trebuie să fie de două tipuri: natural și artificial.
Microclimat
În încăperile în care se desfăşoară activităţi de prelucrare automată a datelor, se vor
asigura condiţii de confort termic;
Atunci când este necesar un microclimat strict controlat, se va urmări să nu se creeze
curenţi de aer supărători.
Umeditatea
Umiditatea aerului va fi mai mare de 40% pentru a se evita uscarea mucoaselor.
Echipamentul aparţinând postului de lucru nu va produce o căldură excesivă, care să
producă disconfortul lucrătorilor.
Zgomot
Zgomotul emis de echipamentele care aparţin postului de muncă nu trebuie să distragă
atenţia şi să perturbe comunicarea verbală.
Imprimantele de mare viteză, care constituie surse de zgomot, vor fi aşezate în încăperi
separate de sala calculatoarelor, izolate fonic şi prevăzute cu geamuri transparente pentru a
facilita vizualizarea procesului de imprimare.
Instalaţiile de ventilare nu trebuie să antreneze prin funcţionarea lor o creştere
semnificativă (mai mare de 3 dB(A)) a nivelurilor sonore din aceste încăperi.
Substanţe periculoase
Emisiile de ozon (O3) de la imprimantele laser trebuie reduse la niveluri neglijabile din
punct de vedere al protecţiei sănătăţii şi securităţii lucrătorilor.
Pardoseala
Să fie în stare corespunzătoare (fără găuri sau obstacole).
Raze ultraviolete
Zi de zi programatorii sunt expuși razelor ultraviolete emise de calculator. Ele nu sunt
simțite deodată, deaceea se recomandă vizitarea medicului și efectuarea controalelor medicale.
43
5.4 Echipamentul de protecție utilizat la locul de muncă
Dotarea cu echipament individual de protecţie se face în scopul prevenirii accidentelor de
muncă şi a îmbolnăvirilor profesionale.
Echipamentele individuale de protecţie trebuie să fie utilizate atunci când riscurile nu pot
fi evitate sau limitate prin mijloacele tehnice de protecţie colectivă sau prin măsuri, metode sau
procedee de organizare a muncii.
Echipamentul individual de protecţie se acordă gratuit angajaţilor de către angajator.
Înainte de alegerea unui echipament individual de protecţie, angajatorul trebuie să
evalueze în ce măsură, echipamentul individual de protecţie pe care intenţionează să-l utilizeze,
răspunde cerinţelor, după cum urmează:
a) analiza şi evaluarea riscurilor care nu pot fi evitate prin alte mijloace;
b) definirea caracteristicilor pe care trebuie să le aibă echipamentul individual de protecţie pentru
a proteja eficient împotriva riscurilor;
c) compararea caracteristicilor precizate la pct.
Echipamente de protecţie individuală de care pot avea nevoie programatorii sunt ochelarii
de protecție.
Ei previn afecatrea si apariția bolilor vazului și pot fi folositi doar cind lucrezi la
calculator.
Încaperea unde se află toată tehnica și unde se efectuiaza procesul de lucru trebuie să fie
dotată cu stingătorul de incendii.
Securitatea și sănătatea în muncă constituie un compartiment foarte important pentru un
angajat și angajator în procesul de lucru. Indiferent de funcția pe care o ocupă, înainte de a fi
angajat, lucratorul trece prin o mulțime de controale, îndeplinește diferite contracte, documente
care fac parte din securitatea și sănătatea în muncă a lui personală. Acolo sunt expuse toate
drepturile și obligațiile lui, reguli de lucru, concedii, echipament etc. Trebuie să atragem o mai
multa atenție acestor lucruri care la prima vedere nu par a fi așa de importante dar mai mult
indiferente. Trebuie să știm ca este spre binele nostru și familiei noastre, deoarece un accident
care poate avea loc cu tine v-a afecta toți membrii familiei tale, atît moral cît și financiar, in cazul
că după aceasta nu vei mai fi capabil de lucru. Viața este a fiecăruia din noi, și nu a celor care ne
oferă un loc de muncă, de aceea trebuie să ne cerem drepturile în securitate și sănătate la locul de
muncă!
44
Concluzii
În urma efectuării lucrării de diplomă am făcut cunoștință cu un nou soft, și anume
Android Studio. Acesta permite crearea aplicațiilor cît simple, atît și sofisticate pentru
dspozitivele electronice a căror sistem de operare este Android și iOS. Android Studio este un
mediu foarte complex ce a apărut în anii 2013-2014 și la moment cel mai utilizat mediu de
dezvoltare folosit de majoritatea developerilor.
Pe parcursul îndeplinirii proiectului de diplomă s-au acumulat noi cunoștințe în ceea ce
ține de elaborarea aplicațiilor, instalarea acestora pe dispozitive. Aplicația creată nu necesită
multe investiții financiare, deoarece fiecare din noi dispune de un computer performant pe care
pot fi dezvoltate aplicațiile. Cunoștințele și experiența acumulată vor fi utile în activitățile din
vitor.
Aplicațiile Android sunt foarte populare în rîndul utilizatorilor simpli din mai multe
motive. Pentru început acestea nu sunt costisitoare, majoritatea fiind gratuite sau la un preț foarte
mic. Acestea dispun de o interfață explicită și un design plăcut, fiind arăgătoare pentru toate
categoriile de vîrste.
Spre final au fost îndeplinite toate obiectivele care au fost stabilite inițial. A fost creată
aplicația care permite supravegherea video la distanță, avînd la dispoziție doar două dispozitive
pe sistemul Android, unul care captează imaginea, iar altul pe care vizualizăm imaginile captate.
Această aplicație poate fi dezvoltată și utilizată în practică în diverse domenii, cum ar fi:
camere de luat vederi din intersecții, de la semafoare, în încăperi. De asemenea, ar putea fi
utilizat pentru captarea imaginilor din aer, dispozitivul fiind atașat de un quad-copter sau alt
aparat zburător.
45
Bobliografie
1 Instrucțiuni de securitate și sănătate în muncă pentru lucrul cu echipamente de calcul.
[Resursă electronică] – regim de acces:
https://osha.europa.eu/fop/romania/ro/good_practice/instructiuni-proprii-de-securitate-si-
sanatate-in-munca-pentru-lucrul-cu-echipamente-de-calcul
2 Boli profesionale. Clasificarea bolilor profesionale. [Resursă electronică] – regim de
acces: http://www.netmedic.ro/boli-profesionale/
3 Laza Laura, Stefănescu Yasim, Popescu Răzvan, Lungu Mihail .Ciclurile de viața a
sistemelor informaționale. București : ARC, 2011.
4 Cojocaru, Vladislav. Ciclurile de viata al SI. [Resursă electronică ] - regim de acces:
http://microsoft.help.need.ro/cursuri/calculatoare/modele-ale-ciclului-de-viata-al-
sistemului-informatic-126527.html.
5 Ștefan Stanciu, Mihaela Ionescu.Managementu Resurselor Umane. București : ASE
București, 2006.
6 Emilian, Radu. Provocarile si introducerile in economie. Bucuresti : Olimpia, 2001.
7 Oleg, Nicolescu. Strategii materiale de firmă. București : Editura Economică, 1995.
8 Rusu Călin, Voicu Marin. ABC-ul managerului. Iași : Editura Gh. Asachi, 1995.Taking
Photos Simply. [Resursă electronică ] - regim de acces:
http://developer.android.com/training/camera/photobasics.html#TaskPath
9 Android Developer. Button. [Resursă electronică ] - regim de acces:
http://developer.android.com/reference/android/widget/Button.html
10 Android Developer. Toasts. The Basics. [Resursă electronică ] - regim de acces:
http://developer.android.com/guide/topics/ui/notifiers/toasts.html
11 Android Developer. BitmapFactory. [Resursă electronică ] - regim de acces:
http://developer.android.com/reference/android/graphics/BitmapFactory.html#decodeByt
eArray(byte[]
12 How to enable my Android App. [Resursă electronică ] - regim de acces:
http://stackoverflow.com/questions/20684553/how-can-i-enable-my-android-app-to-take-
pictures-from-the-camera-without-preview
13 Android for begginers. Taking Photos. [Resursă electronică ] - regim de acces:
https://www.youtube.com/watch?v=pk-80p2ha_Q
14 The Ultimate Android Camera Development Guide. [Resursă electronică ] - regim de
acces: https://www.airpair.com/android/android-camera-development
15 Video Recording and Image Capture using Camera Intents. [Resursă electronică ] - regim
deacces:
http://www.techotopia.com/index.php/Video_Recording_and_Image_Capture_using_Ca
mera_Intents_-_An_Android_Studio_Example
16 Using Androids Camera in your application. [Resursă electronică ] - regim de acces:
http://www.101apps.co.za/articles/using-android-s-camera-in-your-application.html
46
17 Android Server/Client. [Resursă electronică ] - regim de acces: http://android-
er.blogspot.com/2014/02/android-sercerclient-example-client.html
18 Android – Run/Install/Debug Applications over WiFi. [Resursă electronică ] - regim de
acces:http://stackoverflow.com/questions/4893953/android-run-install-debug-
applications-over-wifi
ANEXE
Anexa 1
Dimens.xml
<resources>
<!-- Default screen margins, per the Android Design guidelines. -->
47
<dimen name="activity_horizontal_margin">16dp</dimen>
<dimen name="activity_vertical_margin">16dp</dimen>
</resources>
Strings.xml
<resources>
<string name="app_name">Video1</string>
<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
<string name="title_activity_server">ServerActivity</string>
<string name="title_activity_client">ClientActivity</string>
<string name="title_activity_start">StartActivity</string>
</resources>
Styles.xml
<resources>
<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<!-- Customize your theme here. -->
</style>
</resources>
ApplicationTest.java
package com.example.mozg.video1;
import android.app.Application;
import android.test.ApplicationTestCase;
/**
* <a href="http://d.android.com/tools/testing/testing_android.html">Testing
Fundamentals</a>
*/
public class ApplicationTest extends ApplicationTestCase<Application> {
public ApplicationTest() {
super(Application.class);
}
}
AndroidHttpClient.java
48
package com.turbomanage.httpclient.android;
import android.os.AsyncTask;
import android.os.Build;
import com.turbomanage.httpclient.AsyncHttpClient;
import com.turbomanage.httpclient.RequestHandler;
import com.turbomanage.httpclient.RequestLogger;
import java.net.HttpURLConnection;
/**
* HTTP client for Android providing both synchronous (blocking) and asynchronous
* interfaces so it can be used on or off the UI thread.
*
* <p>Sample usage:</p>
*
* <p>Synchronous (for use off the UI thread in an {@link AsyncTask} or {@link
Runnable})</p>
* <pre>
* AndroidHttpClient httpClient = new AndroidHttpClient("http://www.google.com");
* ParameterMap params = httpClient.newParams().add("q", "GOOG");
* HttpResponse httpResponse = httpClient.get("/finance", params);
* System.out.println(httpResponse.getBodyAsString());
* </pre>
*
* <p>Asynchronous (can be used anywhere, automatically wraps in an {@link
AsyncTask})</p>
* <pre>
* AndroidHttpClient httpClient = new AndroidHttpClient("http://www.google.com");
* ParameterMap params = httpClient.newParams().add("q", "GOOG");
* httpClient.setMaxRetries(3);
* httpClient.get("/finance", params, new AsyncCallback() {
* public void onComplete(HttpResponse httpResponse) {
* System.out.println(httpResponse.getBodyAsString());
* }
* public void onError(Exception e) {
* e.printStackTrace();
49
* }
* });
* </pre>
*
* @author David M. Chandler
*/
public class AndroidHttpClient extends AsyncHttpClient {
static {
disableConnectionReuseIfNecessary();
// See http://code.google.com/p/basic-http-client/issues/detail?id=8
if (Build.VERSION.SDK_INT > 8)
ensureCookieManager();
}
/**
* Constructs a new client with empty baseUrl. When used this way, the path
* passed to a request method must be the complete URL.
*/
public AndroidHttpClient() {
this("");
}
/**
* Constructs a new client using the default {@link RequestHandler} and
* {@link RequestLogger}.
*/
public AndroidHttpClient(String baseUrl) {
super(new AsyncTaskFactory(), baseUrl);
}
/**
* Constructs a client with baseUrl and custom {@link RequestHandler}.
*
* @param baseUrl
* @param requestHandler
*/
public AndroidHttpClient(String baseUrl, RequestHandler requestHandler) {
50
super(new AsyncTaskFactory(), baseUrl, requestHandler);
}
/**
* Work around bug in {@link HttpURLConnection} on older versions of
* Android.
* http://android-developers.blogspot.com/2011/09/androids-http-clients.html
*/
private static void disableConnectionReuseIfNecessary() {
// HTTP connection reuse which was buggy pre-froyo
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO) {
System.setProperty("http.keepAlive", "false");
}
}
}
BasicRequestHandler.java
package com.turbomanage.httpclient;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* Default {@link RequestHandler} used by {@link BasicHttpClient}. It is
* intended to be used for simple requests with small amounts of data only (a
* few kB), as it does no buffering, chunking, streaming, etc. Only character
* set supported is UTF-8. Only {@link String} content is supported. All
* responses are treated as {@link String}s. This class is abstract so that
* it can be easily extended in an anonymous inner class when constructing
* a client.
*
* @author David M. Chandler
*/
public abstract class BasicRequestHandler implements RequestHandler {
51
private final RequestLogger logger;
/**
* Constructs a handler with default logger.
*/
public BasicRequestHandler() {
this(new ConsoleRequestLogger());
}
/**
* Constructs a handler with supplied logger.
*
* @param logger
*/
public BasicRequestHandler(RequestLogger logger) {
this.logger = logger;
}
@Override
public HttpURLConnection openConnection(String urlString) throws IOException {
URL url = new URL(urlString);
HttpURLConnection uc = (HttpURLConnection) url.openConnection();
return uc;
}
@Override
public void prepareConnection(HttpURLConnection urlConnection, HttpMethod
httpMethod,
String contentType) throws IOException {
// Configure connection for request method
urlConnection.setRequestMethod(httpMethod.getMethodName());
urlConnection.setDoOutput(httpMethod.getDoOutput());
urlConnection.setDoInput(httpMethod.getDoInput());
if (contentType != null) {
urlConnection.setRequestProperty("Content-Type", contentType);
}
// Set additional properties
urlConnection.setRequestProperty("Accept-Charset", UTF8);
52
}
@Override
public OutputStream openOutput(HttpURLConnection urlConnection)
throws IOException {
return urlConnection.getOutputStream();
}
@Override
public void writeStream(OutputStream out, byte[] content) throws IOException {
out.write(content);
}
@Override
public InputStream openInput(HttpURLConnection urlConnection)
throws IOException {
return urlConnection.getInputStream();
}
@Override
public byte[] readStream(InputStream in) throws IOException {
int nRead;
byte[] data = new byte[16384];
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
while ((nRead = in.read(data)) != -1) {
buffer.write(data, 0, nRead);
}
buffer.flush();
return buffer.toByteArray();
}
@Override
public boolean onError(HttpRequestException e) {
HttpResponse res = e.getHttpResponse();
if (logger.isLoggingEnabled()) {
logger.log("BasicRequestHandler.onError got");
e.printStackTrace();
}
if (res != null) {
53
int status = res.getStatus();
if (status > 0) {
// Perhaps a 404, 501, or something that will be fixed later
return true;
}
}
// Connection refused, host unreachable, etc.
return false;
}
}
HttpMethod.java
package com.turbomanage.httpclient;
/**
* Enumerated type that represents an HTTP request method.
* Besides the method name, it determines whether the client
* should do the output phase of the connection.
*
* @author David M. Chandler
*/
public enum HttpMethod {
GET(true, false),
POST(true, true),
PUT(true, true),
DELETE(true, false),
HEAD(false, false);
private boolean doInput;
private boolean doOutput;
private HttpMethod(boolean doInput, boolean doOutput) {
this.doInput = doInput;
this.doOutput = doOutput;
}
public boolean getDoInput() {
return doInput;
}
54
/**
* Whether the client should do the write phase, or just read
*
* @return doOutput
*/
public boolean getDoOutput() {
return this.doOutput;
}
/**
* Accessor method.
*
* @return HTTP method name (GET, PUT, POST, DELETE)
*/
public String getMethodName() {
return this.toString();
}
}
HttpRequest.java
package com.turbomanage.httpclient;
/**
* Holds data for an HTTP request to be made with the attached HTTP client.
*
* @author David M. Chandler
*/
public abstract class HttpRequest {
public static final String URLENCODED = "application/x-www-form-
urlencoded;charset=UTF-8";
public static final String MULTIPART = "multipart/form-data";
55
* Constructs a request with optional params appended
* to the query string.
*
* @param path
* @param params
*/
public HttpRequest(String path, ParameterMap params) {
String queryString = null;
if (path != null) {
this.path = path;
}
if (params != null) {
queryString = params.urlEncode();
this.path += "?" + queryString;
}
}
public String getPath() {
return path;
}
public HttpMethod getHttpMethod() {
return httpMethod;
}
public String getContentType() {
return contentType;
}
public byte[] getContent() {
return content;
}
}
56