package com.efisys.quienmepresta.

librerias;

import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.v4.app.Fragment;
import android.support.v4.content.FileProvider;
import android.support.v7.app.AppCompatActivity;
import android.util.Base64;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

import com.efisys.quienmepresta.base.BaseActivity;
import com.efisys.quienmepresta.base.BaseFragment;
import com.google.android.gms.maps.model.TileOverlay;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;

import static com.facebook.FacebookSdk.getApplicationContext;

public class PhotoUtils {

private static PhotoUtils photoUtilsSingleton;

private static Context mContext;
private BitmapFactory.Options generalOptions;
public static final int ACTIVITY_SELECT_FROM_CAMERA = 1040,
ACTIVITY_SELECT_FROM_GALERY = 1030,
ACTIVITY_SELECT_CROP = 1020;
private Uri mImageUri;

private BaseFragment fragmento;

private BaseActivity activity;
private boolean usaFragment;

private String pathTmp = null;

public PhotoUtils(Context context) {

mContext = context;
pathTmp = mContext.getExternalCacheDir().getAbsolutePath()
+ "/temp/";
}

/* metodo SINGLETON encardao de crear unsa sola instancia para toda la

aplicacion*/
public static synchronized PhotoUtils getInstance(Context aplicacionContext) {
 if (photoUtilsSingleton == null) {
photoUtilsSingleton = new PhotoUtils(aplicacionContext);
}
return photoUtilsSingleton;
}
public static int nearest2pow(int value) {
return value == 0 ? 0
: (32 - Integer.numberOfLeadingZeros(value - 1)) / 2;
}

public static Bitmap rotarImagen(Bitmap bm, int maxLengthOfEdge, int

rotateXDegree) {
if (maxLengthOfEdge > bm.getWidth() && maxLengthOfEdge > bm.getHeight()) {
return bm;
} else {
// shrink image
float scale = (float) 1.0;
if (bm.getHeight() > bm.getWidth()) {
scale = ((float) maxLengthOfEdge) / bm.getHeight();
} else {
scale = ((float) maxLengthOfEdge) / bm.getWidth();
}
// CREATE A MATRIX FOR THE MANIPULATION
Matrix matrix = new Matrix();
// RESIZE THE BIT MAP
matrix.postScale(scale, scale);
matrix.postRotate(rotateXDegree);

// RECREATE THE NEW BITMAP

bm = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(),
matrix, false);

matrix = null;
System.gc();

return bm;
}
}
//***********************************
public static int getOrientation(Context context, Uri photoUri) {
/* it's on the external media. */
Cursor cursor = context.getContentResolver().query(photoUri,
new String[]{MediaStore.Images.ImageColumns.ORIENTATION}, null,
null, null);

if (cursor.getCount() != 1) {
return -1;
}
cursor.moveToFirst();
return cursor.getInt(0);
}

public static String encodeToBase64(Bitmap image, String type)

{
Bitmap immagex=image;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
if (type.equals("image/png")) {
image.compress(Bitmap.CompressFormat.PNG, 100, baos);
} else if (type.equals("image/jpg") || type.equals("image/jpeg")) {
 image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
}
byte[] b = baos.toByteArray();
String imageEncoded = Base64.encodeToString(b, Base64.NO_WRAP);

Log.e("LOOK", imageEncoded);
return imageEncoded;
}
public static Bitmap decodeBase64(String input)
{
byte[] decodedByte = Base64.decode(input, 0);
return BitmapFactory.decodeByteArray(decodedByte, 0, decodedByte.length);
}

public File createTemporaryFile(String part, String ext,

Context myContext) throws Exception {

File tempDir = new File(pathTmp);

if (!tempDir.exists()) {
tempDir.mkdir();
}
return File.createTempFile(part, ext, tempDir);
}

public String getImage(Uri uri) {

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
InputStream is = null;

try {
is = mContext.getContentResolver().openInputStream(uri);

BitmapFactory.decodeStream(is, null, options);

is.close();

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
this.generalOptions = options;
System.out.println("String getImagen() " + scaleImage(options, uri, 300));
return scaleImage(options, uri, 300);
}

public String scaleImage(BitmapFactory.Options options, Uri uri,

int targetWidth) {
int rotatedWidth, rotatedHeight;
String Str64Img=null;
if (options == null)
options = generalOptions;

Bitmap bitmap = null;

double ratioWidth = ((float) targetWidth) / (float) options.outWidth;
double ratioHeight = ((float) targetWidth) / (float) options.outHeight;
double ratio = Math.min(ratioWidth, ratioHeight);
int dstWidth = (int) Math.round(ratio * options.outWidth);
 int dstHeight = (int) Math.round(ratio * options.outHeight);
ratio = Math.floor(1.0 / ratio);
int sample = nearest2pow((int) ratio);

options.inJustDecodeBounds = false;
if (sample <= 0) {
sample = 1;
}
options.inSampleSize = (int) sample;
try {
InputStream is;
is = mContext.getContentResolver().openInputStream(uri);
bitmap = BitmapFactory.decodeStream(is, null, options);
if (sample > 1)
bitmap = Bitmap.createScaledBitmap(bitmap, dstWidth, dstHeight,
true);
is.close();

String type ="image/jpg";// mContext.getContentResolver().getType(uri);

Str64Img=encodeToBase64(bitmap,type);

} catch (OutOfMemoryError e) {
e.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}

return Str64Img;
}

public Uri getImageUri() {

System.out.println("getImagenUri " + this.mImageUri);
return this.mImageUri;
}

public void setmImageUri(Uri mImageUri) {

this.mImageUri = mImageUri;
}

public void activaCamara(){

Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
File photo = null;
try {
photo =createTemporaryFile("picture", ".jpg", mContext);
photo.delete();
} catch (Exception e) {
e.printStackTrace();
Log.v(getClass().getSimpleName(), "Can't create file to take
picture!");
}
//mImageUri = Uri.fromFile(photo);
//String authorities = activity.getApplicationContext().getPackageName() +
".fileprovider";
//Uri image = FileProvider.getUriForFile(activity,authorities,photo);
//mIageUri = FileProvider.getUriForFile(activity,authorities,photo);
try {
intent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri);
//intent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri);
if(usaFragment) {
 //String authoritiesF = fragmento.getContext().getPackageName()
+".fileprovider";
String authoritiesF =
fragmento.getActivity().getApplicationContext().getPackageName() +".fileprovider";
Uri image = FileProvider.getUriForFile(activity,authoritiesF,photo);
intent.putExtra(MediaStore.EXTRA_OUTPUT, image);
fragmento.startActivityForResult(intent, ACTIVITY_SELECT_FROM_CAMERA);
}
else {
String authorities = activity.getApplicationContext().getPackageName()
+ ".fileprovider";
Uri image = FileProvider.getUriForFile(activity,authorities,photo);
intent.putExtra(MediaStore.EXTRA_OUTPUT, image);
activity.startActivityForResult(intent, ACTIVITY_SELECT_FROM_CAMERA);
}
} catch (Exception e) {
e.printStackTrace();
Log.v(getClass().getSimpleName(), "Can't create file to take
picture!");
}

/*Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");

File photo = null;
try {
// place where to store camera taken picture
photo = createTemporaryFile("picture", ".jpg",mContext);
photo.delete();
} catch (Exception e) {
Log.v(getClass().getSimpleName(), "Can't create file to take
picture!");
}
mImageUri = Uri.fromFile(photo);
intent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri);
if(usaFragment)
fragmento.startActivityForResult(intent, ACTIVITY_SELECT_FROM_CAMERA);
else
activity.startActivityForResult(intent, ACTIVITY_SELECT_FROM_CAMERA);*/
}

public void activaRecorte(boolean tieneLimites){

//inicializamos nuestro intent
Intent cropIntent = new Intent("com.android.camera.action.CROP");

cropIntent.setDataAndType(mImageUri, "image/*");

//Habilitamos el crop en este intent

cropIntent.putExtra("crop", "true");

if(tieneLimites) {
cropIntent.putExtra("aspectX", 1);
cropIntent.putExtra("aspectY", 1);

//indicamos los limites de nuestra imagen a cortar

cropIntent.putExtra("outputX", 250);
cropIntent.putExtra("outputY", 250);
}

File photo = null;

try {
 photo = createTemporaryFile("picture", ".jpg",mContext);
photo.delete();
} catch (Exception e) {
Log.v(getClass().getSimpleName(),
"Can't create file to take picture!");
}
mImageUri = Uri.fromFile(photo);
cropIntent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri);
//True: retornara la imagen como un bitmap, False: retornara la url de la
imagen la guardada.
//cropIntent.putExtra("return-data", true);

//iniciamos nuestra activity y pasamos un codigo de respuesta.

if(usaFragment) {

fragmento.startActivityForResult(cropIntent, ACTIVITY_SELECT_CROP);
}
else {
activity.startActivityForResult(cropIntent, ACTIVITY_SELECT_CROP);
}
}

public void activaGaleria(){

Intent galleryIntent = new Intent(Intent.ACTION_GET_CONTENT);
galleryIntent.setType("image/*");
if(usaFragment)
fragmento.startActivityForResult(galleryIntent,
ACTIVITY_SELECT_FROM_GALERY);
else
activity.startActivityForResult(galleryIntent,
ACTIVITY_SELECT_FROM_GALERY);
//startActivityForResult(activity,galleryIntent,
ACTIVITY_SELECT_FROM_GALERY,null);
}

public void setFrgActual(BaseFragment frgActual) {

this.fragmento = frgActual;
usaFragment=true;
}

public void setFrgActual(BaseActivity activity){

this.activity=activity;
usaFragment=false;
}

Ya tenemos registrado tu correo (android)

Cambiar el mensaje de Correo de Confirmacion al ser Registro Exitoso en android
Studio
Cambiar cuando se registre pasarlo al Login
Corregir los mensajes en la ortografia
En la consulta hay que poner los datos de nombre si ya los tiene, para que pueda
continuar en el ingreso de los datos!!
Corregir MAYUSCULAS en la APP si todos
Cambiar numero Interior abajo y que numero Exterior quede arriba
no limpio en la pantalla de usar mi ubicacion
scrooll desabilitar
limpiar los campos al cambiar el codigo postal