android-intent länge - Wie gebe ich Daten zwischen Aktivitäten in einer Android-Anwendung weiter?




meta description (25)

Ich habe ein Szenario, in dem nach dem Anmelden über eine Anmeldeseite eine Abmeldeschaltfläche für jede activity .

Beim Abmelden gebe ich die session id des angemeldeten Benutzers an die Abmeldung weiter. Kann mir jemand sagen, wie ich die session id für alle activities verfügbar halten kann?

Jede Alternative zu diesem Fall


Answers

Sie können Shared Preference versuchen, es kann eine gute Alternative für das Freigeben von Daten zwischen den Aktivitäten sein

Session-ID speichern -

SharedPreferences pref = myContexy.getSharedPreferences("Session 
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();

Um sie zu bekommen -

SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);

Die Weitergabe von Daten zwischen Aktivitäten erfolgt hauptsächlich über ein Intent-Objekt.

Zuerst müssen Sie die Daten mit Hilfe der Bundle Klasse an das intent-Objekt anhängen. Rufen Sie die Aktivität anschließend mit den Methoden startActivity() oder startActivityForResult() .

Weitere Informationen hierzu finden Sie in einem Beispiel aus dem Blogbeitrag Daten an eine Aktivität übergeben .


Die bequemste Methode zum Übergeben von Daten zwischen Aktivitäten besteht im Übergeben von Absichten. In der ersten Aktivität, von der Sie Daten senden möchten, sollten Sie Code hinzufügen,

String str = "My Data"; //Data you want to send
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.putExtra("name",str); //Here you will add the data into intent to pass bw activites
v.getContext().startActivity(intent);

Sie sollten auch importieren

import android.content.Intent;

Dann sollten Sie im nächsten Acitvity (SecondActivity) die Daten aus der Absicht mithilfe des folgenden Codes abrufen.

String name = this.getIntent().getStringExtra("name");

Von Aktivität

 int n= 10;
 Intent in = new Intent(From_Activity.this,To_Activity.class);
 Bundle b1 = new Bundle();
 b1.putInt("integerNumber",n);
 in.putExtras(b1);
 startActivity(in);

Zur Aktivität

 Bundle b2 = getIntent().getExtras();
 int m = 0;
 if(b2 != null)
  {
     m = b2.getInt("integerNumber");
  }

Versuchen Sie Folgendes:

Erstelle eine einfache "Helfer" -Klasse (Fabrik für deine Absichten), so:

import android.content.Intent;

public class IntentHelper {
    public static final Intent createYourSpecialIntent(Intent src) {
          return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
    }
}

Dies wird die Fabrik für alle Ihre Intents sein. Jedes Mal, wenn Sie eine neue Absicht benötigen, erstellen Sie in IntentHelper eine statische Factory-Methode. Um eine neue Absicht zu erstellen, solltest du es einfach so sagen:

IntentHelper.createYourSpecialIntent(getIntent());

In deiner Aktivität. Wenn Sie einige Daten in einer "Sitzung" speichern möchten, verwenden Sie einfach Folgendes:

IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);

Und sende diese Absicht. In der Zielaktivität wird Ihr Feld wie folgt verfügbar sein:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Jetzt können wir Intent wie die gleiche alte Sitzung verwenden (wie in Servlets oder JSP ).


Sie können benutzerdefinierte Klassenobjekte auch übergeben, indem Sie eine parzellierbare Klasse erstellen . Am besten parzellieren Sie es, indem Sie Ihre Klasse schreiben und dann einfach auf eine Website wie http://www.parcelabler.com/ einfügen. Klicken Sie auf Build und Sie erhalten neuen Code. Kopieren Sie alles und ersetzen Sie den ursprünglichen Klasseninhalt. Dann-

Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);

und erhalten das Ergebnis in NextActivity like-

Foo foo = getIntent().getExtras().getParcelable("foo");

Jetzt können Sie das foo- Objekt einfach so verwenden, wie Sie es gewohnt wären.


Eine andere Möglichkeit besteht darin, ein öffentliches statisches Feld zu verwenden, in dem Sie Daten speichern, dh:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

/*
 * If you are from transferring data from one class that doesn't
 * extend Activity, then you need to do something like this.
 */ 

public class abc {
    Context context;

    public abc(Context context) {
        this.context = context;
    }

    public void something() {
        context.startactivity(new Intent(context, anyone.class).putextra("key", value));
    }
}

Ergänzende Antwort: Namenskonventionen für die Schlüsselkette

Der tatsächliche Prozess der Datenübergabe wurde bereits beantwortet, die meisten Antworten verwenden jedoch fest codierte Zeichenfolgen für den Schlüsselnamen in der Absicht. Dies ist normalerweise in Ordnung, wenn es nur in Ihrer App verwendet wird. In der Dokumentation wird jedoch empfohlen , die EXTRA_* für standardisierte Datentypen zu verwenden.

Beispiel 1: Verwenden von Intent.EXTRA_* -Tasten

Erste Aktivität

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);

Zweite Aktivität:

Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);

Beispiel 2: Definieren Sie Ihren eigenen static final Endschlüssel

Wenn einer der Intent.EXTRA_* nicht Ihren Anforderungen entspricht, können Sie Ihre eigenen zu Beginn der ersten Aktivität definieren.

static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";

Das Einschließen des Paketnamens ist nur eine Konvention, wenn Sie nur den Schlüssel in Ihrer eigenen App verwenden. Es ist jedoch notwendig, Namenskonflikte zu vermeiden, wenn Sie einen Dienst erstellen, den andere Apps mit einer Absicht aufrufen können.

Erste Aktivität:

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);

Zweite Aktivität:

Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);

Beispiel 3: Verwenden eines String-Ressourcenschlüssels

Obwohl in der Dokumentation nicht erwähnt, empfiehlt diese Antwort die Verwendung einer String-Ressource, um Abhängigkeiten zwischen Aktivitäten zu vermeiden.

strings.xml

 <string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>

Erste Aktivität

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);

Zweite Aktivität

Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));

Ich habe kürzlich Vapor API veröffentlicht , ein jQuery-aromatisiertes Android-Framework, das alle möglichen Aufgaben vereinfacht. Wie bereits erwähnt, ist SharedPreferences eine Möglichkeit, dies zu tun.

VaporSharedPreferences ist als Singleton implementiert, so dass es eine Option gibt, und in Vapour API hat es eine stark überladene .put(...) Methode, so dass Sie sich nicht explizit um den Dateityp kümmern müssen - vorausgesetzt, es wird unterstützt. Es ist auch fließend, also können Sie Anrufe verketten:

$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);

Optional werden auch Änderungen automatisch gespeichert und der Lese- und Schreibprozess unter der Oberfläche vereinheitlicht, so dass Sie nicht wie bei Standard-Android einen Editor explizit abrufen müssen.

Alternativ könnten Sie eine Intent . In der Vapor-API können Sie auch die verkettete überladene .put(...) -Methode für einen VaporIntent :

$.Intent().put("data", "myData").put("more", 568)...

Und geben Sie es als Extra weiter, wie in den anderen Antworten erwähnt. Sie können Extras aus Ihrer Activity abrufen, und wenn Sie VaporActivity wird dies automatisch für Sie erledigt, sodass Sie VaporActivity können:

this.extras()

Um sie am anderen Ende der Activity Sie wechseln, abzurufen.

Hoffe das ist für manche interessant :)


Quellklasse:

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)

Zielklasse (NewActivity-Klasse):

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.view);

    Intent intent = getIntent();

    String fName = intent.getStringExtra("firstName");
    String lName = intent.getStringExtra("lastName");
}

Wenn Sie eine Bitmap zwischen Activites / Fragments übertragen möchten

Aktivität

Um eine Bitmap zwischen Activites zu übergeben

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

Und in der Aktivitätsklasse

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

Fragment

Um eine Bitmap zwischen Fragmenten zu übergeben

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

Um innerhalb des SecondFragment zu erhalten

Bitmap bitmap = getArguments().getParcelable("bitmap");

Große Bitmaps übertragen

Wenn Sie eine fehlgeschlagene Bindertransaktion erhalten, bedeutet dies, dass Sie den Bindertransaktionspuffer überschreiten, indem Sie ein großes Element von einer Aktivität zu einer anderen Aktivität übertragen.

In diesem Fall müssen Sie die Bitmap als Array eines Bytes komprimieren und dann in einer anderen Aktivität wie dieser dekomprimieren

In der FirstActivity

Intent intent = new Intent(this, SecondActivity.class);

ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray(); 
intent.putExtra("bitmapbytes",bytes);

Und in der SecondActivity

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

Sie können Daten zwischen Aktivitäten senden, indem Sie das Intent-Objekt verwenden. Bedenken Sie, dass Sie zwei Aktivitäten haben, nämlich FirstActivity und SecondActivity .

Inside FirstActivity:

Absicht verwenden:

i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)

Innerhalb von SecondActivity

Bundle bundle= getIntent().getExtras();

Jetzt können Sie verschiedene Methoden der Bundle-Klasse verwenden, um Werte von FirstActivity by Key zu erhalten.

ZB bundle.getString("key") , bundle.getDouble("key") , bundle.getInt("key") usw.


Sie müssen nur Extras senden, während Sie Ihre Absicht anrufen.

So was:

Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

Jetzt können Sie die Extras auf der OnCreate Methode Ihrer SecondActivity wie OnCreate SecondActivity .

Wenn der von Ihnen gesendete Wert long :

long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));

Wenn der Wert, den Sie gesendet haben, ein String :

String value = getIntent().getStringExtra("Variable name which you sent as an extra");

Wenn der von Ihnen gesendete Wert ein Boolean Wert ist :

Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);

Erstellen Sie in Ihrer aktuellen Aktivität eine neue Intent :

String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);    
i.putExtra("key",value);
startActivity(i);

Dann in der neuen Aktivität diese Werte abrufen:

Bundle extras = getIntent().getExtras();
if (extras != null) {
    String value = extras.getString("key");
    //The key argument here must match that used in the other activity
}

Verwenden Sie diese Technik, um Variablen von einer Aktivität an die andere zu übergeben.


You can use Intent

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

Another way you can use singleton pattern also:

public class DataHolder {

private static DataHolder dataHolder;
private List<Model> dataList;

public void setDataList(List<Model>dataList) {
    this.dataList = dataList;
}

public List<Model> getDataList() {
    return dataList;
}

public synchronized static DataHolder getInstance() {
    if (dataHolder == null) {
       dataHolder = new DataHolder();
    }
    return dataHolder;
}

}

From your FirstActivity

private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);

On SecondActivity

private List<Model> dataList = DataHolder.getInstance().getDataList();

Hier ist meine Best Practice und es hilft sehr, wenn das Projekt riesig und komplex ist.

Angenommen, ich habe zwei Aktivitäten, LoginActivity und HomeActivity . Ich möchte 2 Parameter (Benutzername und Passwort) von LoginActivity an HomeActivity .

Zuerst erstelle ich meinen HomeIntent

public class HomeIntent extends Intent {

    private static final String ACTION_LOGIN = "action_login";
    private static final String ACTION_LOGOUT = "action_logout";

    private static final String ARG_USERNAME = "arg_username";
    private static final String ARG_PASSWORD = "arg_password";


    public HomeIntent(Context ctx, boolean isLogIn) {
        this(ctx);
        //set action type
        setAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);
    }

    public HomeIntent(Context ctx) {
        super(ctx, HomeActivity.class);
    }

    //This will be needed for receiving data
    public HomeIntent(Intent intent) {
        super(intent);
    }

    public void setData(String userName, String password) {
        putExtra(ARG_USERNAME, userName);
        putExtra(ARG_PASSWORD, password);
    }

    public String getUsername() {
        return getStringExtra(ARG_USERNAME);
    }

    public String getPassword() {
        return getStringExtra(ARG_PASSWORD);
    }

    //To separate the params is for which action, we should create action
    public boolean isActionLogIn() {
        return getAction().equals(ACTION_LOGIN);
    }

    public boolean isActionLogOut() {
        return getAction().equals(ACTION_LOGOUT);
    }
}

So gebe ich die Daten in meiner LoginActivity weiter

public class LoginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        String username = "phearum";
        String password = "pwd1133";
        final boolean isActionLogin = true;
        //Passing data to HomeActivity
        final HomeIntent homeIntent = new HomeIntent(this, isActionLogin);
        homeIntent.setData(username, password);
        startActivity(homeIntent);

    }
}

HomeActivity Schritt, hier ist, wie ich die Daten in HomeActivity

public class HomeActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_home);

        //This is how we receive the data from LoginActivity
        //Make sure you pass getIntent() to the HomeIntent constructor
        final HomeIntent homeIntent = new HomeIntent(getIntent());
        Log.d("HomeActivity", "Is action login?  " + homeIntent.isActionLogIn());
        Log.d("HomeActivity", "username: " + homeIntent.getUsername());
        Log.d("HomeActivity", "password: " + homeIntent.getPassword());
    }
}

Erledigt! Cool :) Ich möchte nur meine Erfahrungen teilen. Wenn Sie an kleinen Projekten arbeiten, sollte dies nicht das große Problem sein. Aber wenn Sie an einem großen Projekt arbeiten, tut es wirklich weh, wenn Sie Fehler korrigieren oder beheben wollen.


"Passing Intent Extras" ist ein guter Ansatz, wie Erich bemerkte.

Das Application ist jedoch eine andere Möglichkeit, und es ist manchmal einfacher, wenn derselbe Zustand über mehrere Aktivitäten hinweg behandelt wird (im Gegensatz zu dem, dass es überall benötigt wird) oder Objekte, die komplexer sind als Primitive und Strings.

Sie können die Anwendung erweitern und dann festlegen, was Sie dort haben wollen und von jeder Aktivität (in derselben Anwendung) mit getApplication() .

Denken Sie auch daran, dass andere Ansätze wie die Statik problematisch sein können, da sie zu Speicherlecks führen können . Anwendung hilft auch, dies zu lösen.


Der Standardansatz.

Intent i = new Intent(this, ActivityTwo.class);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
String getrec=textView.getText().toString();
Bundle bundle = new Bundle();
bundle.putString(“stuff”, getrec);
i.putExtras(bundle);
startActivity(i);

Rufen Sie jetzt in Ihrer zweiten Aktivität Ihre Daten aus dem Bündel ab:

Hol dir das Bündel

Bundle bundle = getIntent().getExtras();

Extrahiere die Daten ...

String stuff = bundle.getString(“stuff”); 

If you use kotlin:

In MainActivity1:

var intent=Intent(this,MainActivity2::class.java)
intent.putExtra("EXTRA_SESSION_ID",sessionId)
startActivity(intent)

In MainActivity2:

if (intent.hasExtra("EXTRA_SESSION_ID")){
    var name:String=intent.extras.getString("sessionId")
}

Sie können SharedPreferences ...

  1. Protokollierung SharedPreferences Sitzungs-ID in SharedPreferences

    SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
    Editor editor = preferences.edit();
    editor.putString("sessionId", sessionId);
    editor.commit();
    
  2. Ausloggen. Time fetch Session ID in geteilten Preferences

    SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE);
    String sessionId = preferences.getString("sessionId", null);
    

Wenn Sie nicht die erforderliche Sitzungs-ID haben, entfernen Sie gemeinsam genutzte Einstellungen:

SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();

Das ist sehr nützlich, weil Sie einmal den Wert speichern und dann irgendwo eine Aktivität abrufen.


Aktualisiert Hinweis: Ich hatte die Verwendung von SharedPreference . Es hat eine einfache API und ist über die Aktivitäten einer Anwendung zugänglich. Dies ist jedoch eine plumpe Lösung und stellt ein Sicherheitsrisiko dar, wenn sensible Daten weitergegeben werden. Es ist am besten, Absichten zu verwenden. Es verfügt über eine umfangreiche Liste von überladenen Methoden, die verwendet werden können, um viele verschiedene Datentypen zwischen Aktivitäten besser zu übertragen. intent.putExtra Sie einen Blick auf intent.putExtra . Dieser link stellt die Verwendung von putExtra sehr gut dar.

Bei der Weitergabe von Daten zwischen Aktivitäten besteht meine bevorzugte Vorgehensweise darin, eine statische Methode für die relevante Aktivität zu erstellen, die die erforderlichen Parameter enthält, um die Absicht zu starten. Das bietet dann einfach Setup- und Abrufparameter. So kann es aussehen

public class MyActivity extends Activity {
    public static final String ARG_PARAM1 = "arg_param1";
...
public static getIntent(Activity from, String param1, Long param2...) {
    Intent intent = new Intent(from, MyActivity.class);
        intent.putExtra(ARG_PARAM1, param1);
        intent.putExtra(ARG_PARAM2, param2);
        return intent;
}

....
// Use it like this.
startActivity(MyActvitiy.getIntent(FromActivity.this, varA, varB, ...));
...

Dann können Sie eine Absicht für die beabsichtigte Aktivität erstellen und sicherstellen, dass Sie alle Parameter haben. Sie können sich an Fragmente anpassen. Ein einfaches Beispiel oben, aber Sie bekommen die Idee.


Versuche dies:

AktuelleAktivität.java

Intent intent = new Intent(currentActivity.this, TargetActivity.class);
intent.putExtra("booktype", "favourate");
startActivity(intent);

ZielAktivität.java

Bundle b = getIntent().getExtras();
String typesofbook = b.getString("booktype");

Charlie Collins gab mir eine perfekte answer mit der Application.class . Ich war mir nicht bewusst, dass wir es so leicht unterklassieren konnten. Hier ist ein vereinfachtes Beispiel, das eine benutzerdefinierte Anwendungsklasse verwendet.

AndroidManifest.xml

Geben Sie das Attribut android:name an, um Ihre eigene Anwendungsklasse zu verwenden.

...
<application android:name="MyApplication"
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
....

MyApplication.java

Verwenden Sie dies als globalen Referenzhalter. Es funktioniert gut in einem Prozess.

public class MyApplication extends Application {
    private MainActivity mainActivity;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }
    public MainActivity getMainActivity() { return mainActivity; }
}

MainActivity.java

Setzen Sie den globalen "Singleton" -Verweis auf die Anwendungsinstanz.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ((MyApplication)getApplication()).setMainActivity(this);
    }
    ...

}

MyPreferences.java

Ein einfaches Beispiel, in dem ich eine Hauptaktivität aus einer anderen Aktivitätsinstanz verwende.

public class MyPreferences extends PreferenceActivity
            implements SharedPreferences.OnSharedPreferenceChangeListener {
    @SuppressWarnings("deprecation")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
        if (!key.equals("autostart")) {
            ((MyApplication)getApplication()).getMainActivity().refreshUI();
        }
    }
}

use these code for every image in select from SdCard or drewable to convert bitmap object.

Resources res = getResources();
WindowManager window = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
Display display = window.getDefaultDisplay();
@SuppressWarnings("deprecation")
int width = display.getWidth();
@SuppressWarnings("deprecation")
int height = display.getHeight();
try {
    if (bitmap != null) {
        bitmap.recycle();
        bitmap = null;
        System.gc();
    }
    bitmap = Bitmap.createScaledBitmap(BitmapFactory
        .decodeFile(ImageData_Path.get(img_pos).getPath()),
        width, height, true);
} catch (OutOfMemoryError e) {
    if (bitmap != null) {
        bitmap.recycle();
        bitmap = null;
        System.gc();
    }
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inPreferredConfig = Config.RGB_565;
    options.inSampleSize = 1;
    options.inPurgeable = true;
    bitmapBitmap.createScaledBitmap(BitmapFactory.decodeFile(ImageData_Path.get(img_pos)
        .getPath().toString(), options), width, height,true);
}
return bitmap;

use your image path instend of ImageData_Path.get(img_pos).getPath() .







android android-intent android-activity