android - setresult - startactivityforresult fragment

Cómo usar el método onActivityResult de otra clase que no sea Activity

Question

Estoy creando una aplicación donde necesito encontrar la ubicación actual del usuario.

Así que aquí me gustaría hacer una tarea como cuando el usuario regresa de esa intención del sistema, mi tarea debería hacerse después de eso (Mostrar la ubicación actual de los usuarios)

Así que estoy planeando usar OnActivityResult() .

protected void onActivityResult(int requestCode, int resultCode, Intent data) {

}

Pero el problema es que no sé cómo puedo usar ese método en una clase que no está extendiendo la Actividad.

Por favor, alguien me dé una idea de cómo puedo lograr esto?

Answer 1

Cree una clase interna en la clase que no sea de actividad y defina su controlador de resultados de actividad en ella:

class singletonActivity extends Activity{
  protected void onActivityResult(...){
    // do whatever ..
  }
}

intuirlo para llamar a startActivityForResult

Activity actv = new singletonActivity(..)
actv.startActivityForResult(intent ..)

Se llamará su controlador. :)

ps: es posible que tengas que incluir algunas anulaciones. sólo déjalos vacíos.

pps: este es el estilo de old school java mouseListenerAdapter ~ Oo>

Answer 2

Cuando inicia una actividad con el método startActivityForResult desde una actividad, solo la persona que llama recibirá el resultado.

Así que puedes manejar el resultado y pasarlo a la tarea o actualizar la interfaz de usuario de esa actividad:

int MY_REQUEST_ID = 1;

public void onClick(){
    //Select a contact.
    startActivityForResult(
             new Intent(Intent.ACTION_PICK,
             new Uri("content://contacts")),
             MY_REQUEST_ID);
}    

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
     if(requestCose == MY_REQUEST_ID && resultCode == SUCCESS) {
         MyAsyncTask task = new AsyncTask(requestCode, resultCode, data);
         task.execute();
         // or update the UI
         textView.setText("Hi, activity result: "+ resultCode);
     }
}

Answer 3

Finalmente obtuve lo que necesito y también la solución para esta pregunta.

 Activity con;
Intent intent_= new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
            con.startActivityForResult(intent_, 0);

Ahora puedo crear un método aquí,

public void startActivityForResult(Intent i, int code)
{
    Log.e("", "insede method startActivityForResult()");
}

Al utilizar este sistema, no se crea una subactividad para mi intención, por lo que este método se llama solo después de que el usuario vuelve de la intención.

Answer 4

Lo estoy usando así, esto puede ser útil para otros.

En mi fragmento tengo

// Upload Cover Photo On Button Click
btn.setOnClickListener(new View.OnClickListener() {

    @Override
    public void onClick(View v) {

        // Start The Image Cropper And Go To onActivityResult
        Intent intent = ImageManager.startImageCropper(getContext());
        startActivityForResult(intent, CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE);

    }
});

Entonces llamando el resultado como este en el fragmento

// On Activity Result for Start Activity For Result
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {

    super.onActivityResult(requestCode, resultCode, data);

    // Get The Image From Image Cropper
    Uri resultUri = ImageManager.activityResult(requestCode, resultCode, data, getContext());
}

La clase pública / funciones que soportan estos son

public class ImageManager {

    // Start Image Cropper
    public static Intent startImageCropper(Context context) {

        // Crop Image
        Intent intent = CropImage.activity()
                .setGuidelines(CropImageView.Guidelines.ON)
                .setActivityTitle("Title")
                .setCropMenuCropButtonTitle("Save")
                .setAutoZoomEnabled(true)
                .setAspectRatio(1, 1)
                .getIntent(context);

        return intent;

    }

    public static Uri activityResult(int requestCode, int resultCode, Intent data, Context context) {

        // Handle Cropped Image

        Uri resultUri = null;

        if (requestCode == CropImage.CROP_IMAGE_ACTIVITY_REQUEST_CODE) {
            CropImage.ActivityResult result = CropImage.getActivityResult(data);
            if (resultCode == Activity.RESULT_OK) {
                resultUri = result.getUri();

            } else if (resultCode == CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE) {
                Exception error = result.getError();
                Toast.makeText(context, (CharSequence) error, Toast.LENGTH_SHORT).show();
            }

        }
        return resultUri;
    }
}

Answer 5

Necesitas una Actividad para recibir el resultado.

Si es solo para la organización del código, llame a otra clase de la clase Activty.

public class Result {
    public static void activityResult(int requestCode, int resultCode, Intent data){
          ...
   }
}


@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
       Result.activityResult(requestCode,resultCode,data);
        ...
    }

Answer 6

OnActivityResult() registrar una Activity en esta clase y luego usar OnActivityResult() para esa actividad.

Answer 7

No puedes llamar a este método fuera de su alcance.

protected void onActivityResult (int requestCode, int resultCode, Intent data)

Si el método está protegido como este caso, puede ver la tabla de niveles de acceso para saber cómo proceder.

|-----------------------------------------------------------|
|                     ACCESS LEVELS                         |
|------------------|---------|---------|----------|---------|
|      Modifier    |  Class  | Package | Subclass |  World  |
|------------------|---------|---------|----------|---------|
|      public      |    Y    |    Y    |    Y     |    Y    |
|------------------|---------|---------|----------|---------|
|      protected   |    Y    |    Y    |    Y     |    N    |
|------------------|---------|---------|----------|---------|
|      no modifier |    Y    |    Y    |    N     |    N    |
|------------------|---------|---------|----------|---------|
|      private     |    Y    |    N    |    N     |    N    |
|------------------|---------|---------|----------|---------|

Como puede ver, solo se puede llamar a este método desde el paquete android.app.* , La Activity y sus subclases.

SOLUCIÓN:

Necesitas hacer algo como esto:

Tenemos un ImagePicker clase para seleccionar una imagen de Galería o Cámara o Eliminarla . Esta clase debe invocar onActivityResult si el usuario desea eliminar una imagen (No necesitamos iniciar una Activity para obtener un resultado que ya conocemos).

public class ImagePicker {
    private ImagePickerDelegate delegate;

    public ImagePicker (ImagePickerDelegate delegate) {
        this.delegate = delegate;
    }

    //Will explain this two methods later
    public void show() {
        //Some code to show AlertDialog
    }

    public void handleResponse(Intent data) {
        //Some code to handle onActivityResult
    }

    //Our interface to delegate some behavior 
    public interface ImagePickerDelegate {
        void onImageHandled(Bitmap image);
        void onImageError();
        void onImageDeleted();
    }
}

Para utilizar esta clase en nuestra Activity , necesitamos implementar los métodos de delegado y pasar nuestra actividad como delegado de ImagePicker :

public class MyActivity extends Activity implements ImagePicker.ImagePickerDelegate {
    ImagePicker imagePicker;    

    @OnClick(R.id.image_edit)
    public void selectImage () {
        imagePicker = new ImagePicker(this);
        imagePicker.show();
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == ImagePicker.REQUEST_IMAGE_PICKER && resultCode == RESULT_OK) {
            imagePicker.handleResponse(data);
        }
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    public void onImageHandled(Bitmap image) {
        //handle image resized
        imageView.setImageBitmap(image);
    }

    @Override
    public void onImageError() {
        //handle image error
        Toast.makeText(this, "Whoops - unexpected error!", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onImageDeleted() {
        //handle image deleted
        groupImageView.setImageBitmap(null);
        groupImageView.setImageResource(R.drawable.ic_pick_picture);
    }
}

Finalmente, necesitamos hacer miles de métodos delegados para ser llamados, y eso sucede en show() y handleResponse(Intent data) :

//The show method create and dialog with 3 options,
//the important thing here, is when an option is selected
public void show() {
    //Inflating some views and creating dialog...

    NavigationView navView = (NavigationView)viewInflated.findViewById(R.id.navigation_menu);
    navView.setNavigationItemSelectedListener( new NavigationView.OnNavigationItemSelectedListener() {
        @Override
        public boolean onNavigationItemSelected(MenuItem menuItem) {
            switch (menuItem.getItemId()) {
                case R.id.action_select_image:
                    Intent pickPhoto = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                    activity.startActivityForResult(pickPhoto , REQUEST_IMAGE_PICKER);
                    break;
                case R.id.action_take_picture:
                    Intent takePicture = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    activity.startActivityForResult(takePicture, REQUEST_IMAGE_PICKER);
                    break;
                case R.id.action_delete_image:
                    delegate.onImageDeleted(); //send response to activity
                    break;
            }
            alertDialog.dismiss();
            return true;
        }
    });

    //Show dialog...
}


//this method is called from onActivityResult
public void handleResponse(Intent data) {
    try {
        //Retrieve and resize image...
        delegate.onImageHandled(image); //send the image to activity
    } catch (Exception e) {
        e.printStackTrace();
        delegate.onImageError(); //send error to activity
    }
}

Al final, lo que tenemos es una class que puede llamar a un método en su Activity lugar de onActivityResult , pero cuando obtiene un resultado en onActivityResult , debe manejarlo en esa class