මට පිවිසුම් පිටුවක් හරහා පිවිසීමෙන් පසු, buttonඑක් එක් පිටවීම සිදු වන අවස්ථාවක් activityතිබේ.

ක්ලික් කිරීමෙන් sign-out, මම session idපුරනය වී ඇති පරිශීලකයාගේ වරනය ඉවත් වනු ඇත. session idසැමට ලබා ගත හැකි ආකාරය පිළිබඳව කිසිවෙකුට මග පෙන්විය හැකිද activities?

මෙම නඩුවට ඕනෑම විකල්පයක්

මෙය කිරීමට ඇති පහසුම ක්‍රමය වනුයේ Intentඔබ ක්‍රියාකාරකම් ආරම්භ කිරීමට භාවිතා කරන සැසිවාර හැඳුනුම්පත පිටවීමේ ක්‍රියාකාරකම් වෙත යැවීමයි :

Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);

ඊළඟ ක්‍රියාකාරකම සඳහා එම අභිප්‍රාය වෙත ප්‍රවේශ වන්න:

String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");

මෙම ලේඛන අපේක්ෂාවන් සඳහා වැඩි විස්තර ( "ස්තරයක්" නමින් මෙම කොටස සලකා බලන) ඇත.

ඔබගේ වර්තමාන ක්‍රියාකාරකම තුළ, නව එකක් සාදන්න Intent:

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

නව ක්‍රියාකාරකම තුළ, එම අගයන් ලබා ගන්න:

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

එක් ක්‍රියාකාරකමකින් අනෙකට විචල්‍යයන් යැවීමට මෙම තාක්ෂණය භාවිතා කරන්න.

පසුකර අභිප්රාය එරික් සඳහන් කර ඇති පරිදි අතිරේක අංග හොඳ ප්රවේශයක්.

මෙම අයදුම් වස්තුව වුවත් තවත් ක්රමයක් වන අතර, (ලබා / එය සෑම තැනකම දමා ඇති විරුද්ධ ලෙස) බහු කටයුතු හරහා එම රාජ්ය සමඟ කටයුතු කරන විට එය සමහර පහසු වන අතර, හෝ සැලකෙතත් හා නූල් වඩා වඩාත් සංකීර්ණ වස්තූන්.

ඔබට යෙදුම දීර් extend කළ හැකිය, ඉන්පසු ඔබට අවශ්‍ය ඕනෑම දෙයක් සකසා / ලබාගෙන ඕනෑම ක්‍රියාකාරකමකින් (එකම යෙදුමකින්) getApplication () සමඟ ප්‍රවේශ විය හැකිය.

සංඛ්‍යාලේඛන වැනි ඔබ දකින වෙනත් ප්‍රවේශයන් ගැටළු සහගත විය හැකි බව මතක තබා ගන්න මතක කාන්දු වීමට හේතු විය හැකි බව මතක තබා ගන්න . යෙදුමද මෙය විසඳීමට උපකාරී වේ.

මූලාශ්‍ර පන්තිය:

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

ගමනාන්ත පන්තිය (නව ක්‍රියාකාරකම් පන්තිය):

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");
}

ඔබේ අභිප්‍රාය අමතමින් ඔබට අමතර යැවිය යුතුය.

මෙවැනි:

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

දැන් OnCreateඔබේ ක්‍රමවේදය මතSecondActivity ඔබට මේ වගේ අමතර දේ ලබා ගත හැකිය.

ඔබ එවූ අගය පහත පරිදි නම්long :

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

ඔබ එවූ අගය නම්String :

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

ඔබ එවූ අගය නම්Boolean :

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

සන්දර්භය තුළ දේවල් බැලීමට එය මට උපකාරී වේ. මෙන්න උදාහරණ දෙකක්.

දත්ත ඉදිරියට යැවීම

ප්‍රධාන ක්‍රියාකාරකම

• ඔබට යැවීමට අවශ්‍ය දත්ත යතුරු අගය යුගලයක් සහිත අභිප්‍රායයකින් දමන්න. යතුර සඳහා සම්මුතීන් නම් කිරීම සඳහා මෙම පිළිතුර බලන්න .
• සමඟ දෙවන ක්‍රියාකාරකම ආරම්භ කරන්න startActivity.

MainActivity.java

public class MainActivity extends AppCompatActivity {

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // get the text to pass
        EditText editText = (EditText) findViewById(R.id.editText);
        String textToPass = editText.getText().toString();

        // start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        intent.putExtra(Intent.EXTRA_TEXT, textToPass);
        startActivity(intent);
    }
}

දෙවන ක්‍රියාකාරකම

• දෙවන ක්‍රියාකාරකම ආරම්භ කිරීමට ඔබ භාවිතා getIntent()කරයි Intent. එවිට ඔබට getExtras()පළමු ක්‍රියාකාරකමෙහි අර්ථ දක්වා ඇති යතුර සමඟ දත්ත උකහා ගත හැකිය . අපගේ දත්ත නූලක් බැවින් අපි getStringExtraමෙහි භාවිතා කරමු .

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

        // get the text from MainActivity
        Intent intent = getIntent();
        String text = intent.getStringExtra(Intent.EXTRA_TEXT);

        // use the text in a TextView
        TextView textView = (TextView) findViewById(R.id.textView);
        textView.setText(text);
    }
}

දත්ත ආපසු ලබා දීම

ප්‍රධාන ක්‍රියාකාරකම

• startActivityForResultඅත්තනෝමතික ප්‍රති result ල කේතයක් ලබා දෙමින් දෙවන ක්‍රියාකාරකම ආරම්භ කරන්න .
• අභිබවා යන්න onActivityResult . දෙවන ක්‍රියාකාරකම අවසන් වූ විට මෙය හැඳින්වේ. ප්‍රති result ල කේතය පරික්ෂා කිරීමෙන් එය සැබවින්ම දෙවන ක්‍රියාකාරකම බව ඔබට සහතික කළ හැකිය. (ඔබ එකම ප්‍රධාන ක්‍රියාකාරකමකින් විවිධ ක්‍රියාකාරකම් ආරම්භ කරන විට මෙය ප්‍රයෝජනවත් වේ.)
• ආපසු ලැබීමෙන් ඔබට ලැබුණු දත්ත උපුටා ගන්න Intent. යතුරු-අගය යුගලයක් භාවිතයෙන් දත්ත උපුටා ගනු ලැබේ. මට යතුර සඳහා ඕනෑම නූලක් භාවිතා කළ හැකි නමුත් මම Intent.EXTRA_TEXTපෙළ යවන බැවින් පෙර නියම කළ ඒවා භාවිතා කරමි.

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private static final int SECOND_ACTIVITY_REQUEST_CODE = 0;

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // Start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);
    }

    // This method is called when the second activity finishes
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // check that it is the SecondActivity with an OK result
        if (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {

                // get String data from Intent
                String returnString = data.getStringExtra(Intent.EXTRA_TEXT);

                // set text view with string
                TextView textView = (TextView) findViewById(R.id.textView);
                textView.setText(returnString);
            }
        }
    }
}

දෙවන ක්‍රියාකාරකම

• ඔබට පෙර ක්‍රියාකාරකමට යැවීමට අවශ්‍ය දත්ත අ Intent. Intentයතුරු අගය යුගලයක් භාවිතා කරමින් දත්ත ගබඩා කර ඇත . මම Intent.EXTRA_TEXTමගේ යතුර සඳහා භාවිතා කිරීමට තෝරා ගත්තා .
• ප්‍රති RESULT_OKdata ලය සකසා ඔබේ දත්ත රඳවා තබා ගැනීමේ අභිප්‍රාය එක් කරන්න.
• අමතන්න finish()දෙවන ක්‍රියාකාරකම වසා දැමීමට .

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

    // "Send text back" button click
    public void onButtonClick(View view) {

        // get the text from the EditText
        EditText editText = (EditText) findViewById(R.id.editText);
        String stringToPassBack = editText.getText().toString();

        // put the String to pass back into an Intent and close this activity
        Intent intent = new Intent();
        intent.putExtra(Intent.EXTRA_TEXT, stringToPassBack);
        setResult(RESULT_OK, intent);
        finish();
    }
}

යාවත්කාලීන කළ සටහන SharedPreference භාවිතය මා සඳහන් කළ බව සලකන්න . එය සරල API එකක් ඇති අතර යෙදුමක ක්‍රියාකාරකම් හරහා ප්‍රවේශ විය හැකිය. නමුත් මෙය අවුල් සහගත විසඳුමක් වන අතර ඔබ සංවේදී දත්ත පසුකර ගියහොත් එය ආරක්ෂක අවදානමකි. අභිප්රායන් භාවිතා කිරීම වඩාත් සුදුසුය. ක්‍රියාකාරකම් අතර විවිධ දත්ත වර්ග වඩා හොඳින් මාරු කිරීම සඳහා භාවිතා කළ හැකි අධි බර පටවන ක්‍රම පිළිබඳ පුළුල් ලැයිස්තුවක් එහි ඇත. Intent.putExtra දෙස බලන්න . මෙම සබැඳිය මඟින් putExtra භාවිතය ඉතා හොඳින් ඉදිරිපත් කරයි.

ක්‍රියාකාරකම් අතර දත්ත සම්ප්‍රේෂණය කිරීමේදී, මගේ ප්‍රියතම ප්‍රවේශය වන්නේ අදාළ පරාමිතීන් ඇතුළත් වන අදාළ ක්‍රියාකාරකම් සඳහා ස්ථිතික ක්‍රමයක් නිර්මාණය කිරීමයි. එමඟින් පහසුවෙන් සැකසීමට සහ පරාමිතීන් ලබා ගැනීමට හැකි වේ. එබැවින් එය මේ ආකාරයෙන් පෙනිය හැකිය

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, ...));
...

එවිට ඔබට අපේක්ෂිත ක්‍රියාකාරකම් සඳහා අභිප්‍රායක් නිර්මාණය කළ හැකි අතර ඔබට සියලු පරාමිතීන් ඇති බව සහතික කරන්න. ඔබට කොටස් වලට අනුවර්තනය විය හැකිය. ඉහත සරල උදාහරණයක්, නමුත් ඔබට අදහස ලැබේ.

පහත සඳහන් දේ කිරීමට උත්සාහ කරන්න:

මේ ආකාරයට සරල "සහායක" පන්තියක් (ඔබේ අභිප්‍රාය සඳහා කර්මාන්ත ශාලාව) සාදන්න:

import android.content.Intent;

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

මෙය ඔබගේ සියලු අභිප්‍රායන් සඳහා කර්මාන්ත ශාලාව වනු ඇත. ඔබට නව අභිප්‍රායක් අවශ්‍ය සෑම අවස්ථාවකම, IntentHelper හි ස්ථිතික කර්මාන්තශාලා ක්‍රමයක් සාදන්න. නව අභිප්‍රායයක් නිර්මාණය කිරීම සඳහා ඔබ එය මෙසේ පැවසිය යුතුය:

IntentHelper.createYourSpecialIntent(getIntent());

ඔබගේ ක්‍රියාකාරකම තුළ. "සැසියක" සමහර දත්ත "සුරැකීමට" ඔබට අවශ්‍ය විට පහත සඳහන් දෑ භාවිතා කරන්න:

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

මෙම අභිප්‍රාය යවන්න. ඉලක්කගත ක්‍රියාකාරකම් වලදී ඔබේ ක්ෂේත්‍රය පහත පරිදි වේ:

getIntent().getStringExtra("YOUR_FIELD_NAME");

දැන් අපට පැරණි සැසිය වැනි (සර්වට්ලට් හෝ ජේඑස්පී වැනි ) අභිප්‍රාය භාවිතා කළ හැකිය .

පාර්සල් කළ හැකි පන්තියක් සෑදීමෙන් ඔබට අභිරුචි පන්ති වස්තු සමත් කළ හැකිය . එය පාර්සල් කළ හැකි හොඳම ක්‍රමය නම් ඔබේ පන්තිය ලිවීම හා එය http://www.parcelabler.com/ වැනි වෙබ් අඩවියකට ඇලවීමයි . ගොඩනැගීම මත ක්ලික් කරන්න, එවිට ඔබට නව කේතයක් ලැබෙනු ඇත. මේ සියල්ල පිටපත් කර මුල් පන්තියේ අන්තර්ගතය ප්‍රතිස්ථාපනය කරන්න. ඉන්පසු-

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

NextActivity වැනි ප්‍රති result ලය ලබා ගන්න-

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

දැන් ඔබට සරලවම foo වස්තුව භාවිතා කළ හැකිය .

තවත් ක්‍රමයක් නම් ඔබ දත්ත ගබඩා කරන පොදු ස්ථිතික ක්ෂේත්‍රයක් භාවිතා කිරීමයි, එනම්:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

ක්‍රියාකාරකම් අතර දත්ත සම්ප්‍රේෂණය කිරීමට වඩාත්ම පහසු ක්‍රමය වන්නේ අභිප්‍රායන් සම්මත කිරීමයි. ඔබට දත්ත යැවීමට අවශ්‍ය පළමු ක්‍රියාකාරකමේදී, ඔබ කේතයක් එකතු කළ යුතුය,

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);

ඔබ ද ආනයනය කළ යුතුය

import android.content.Intent;

ඊළඟ ඇක්ටිවිටි (දෙවන ක්‍රියාකාරිත්වය) තුළ, ඔබ පහත කේතය භාවිතා කරමින් අභිප්‍රායයෙන් දත්ත ලබා ගත යුතුය.

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

ඔබට භාවිතා කළ හැකිය SharedPreferences...

1. ලොග් වීම. කාල ගබඩා සැසි හැඳුනුම්පතSharedPreferences

   SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
   Editor editor = preferences.edit();
   editor.putString("sessionId", sessionId);
   editor.commit();

2. වරන්න. හවුල් වර්‍ගවල සැසි හැඳුනුම්පත ලබා ගැනීම

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

ඔබට අවශ්‍ය සැසි හැඳුනුම්පතක් නොමැති නම්, හවුල් පෙරදසුන් ඉවත් කරන්න:

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

එය ඉතා ප්‍රයෝජනවත් වේ, මන්ද එක් වරක් ඔබ අගය ඉතිරි කර පසුව ඕනෑම ක්‍රියාකාරකමක් ලබා ගනී.

සම්මත ප්රවේශය.

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);

දැන් ඔබගේ දෙවන ක්‍රියාකාරකම තුළ ඔබේ දත්ත මිටියෙන් ලබා ගන්න:

මිටියක් ලබා ගන්න

Bundle bundle = getIntent().getExtras();

දත්ත උපුටා ගැනීම…

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

ක්‍රියාකාරකමෙන්

 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);

ක්‍රියාකාරකමට

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

අභිප්‍රාය වස්තුව භාවිතයෙන් ක්‍රියාකාරකම් අතර දත්ත යැවිය හැකිය. ඔබ එනම් කටයුතු දෙකක් සලකා බලන්න FirstActivityසහSecondActivity .

පළමු ක්‍රියාකාරිත්වය ඇතුළත:

අභිප්‍රාය භාවිතා කිරීම:

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

දෙවන ක්‍රියාකාරිත්වය තුළ

Bundle bundle= getIntent().getExtras();

FirstActivity වෙතින් Key මඟින් අගයන් ලබා ගැනීම සඳහා දැන් ඔබට විවිධ මිටි පන්ති ක්‍රම භාවිතා කළ හැකිය.

උදා: bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key")ආදිය

ඔබට ක්‍රියාකාරකම් / කොටස් අතර බිට්මැප් මාරු කිරීමට අවශ්‍ය නම්

ක්‍රියාකාරකම

ක්‍රියාකාරකම් අතර බිටු සිතියමක් සම්මත කිරීමට

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

සහ ක්‍රියාකාරකම් පන්තියේ

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

කැබැල්ල

කොටස් අතර බිටු සිතියමක් සම්මත කිරීමට

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

දෙවන රාමුව තුළ ලැබීමට

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

විශාල බිට්මැප් මාරු කිරීම

ඔබ අසාර්ථක බන්ධන ගනුදෙනුවක් ලබා ගන්නේ නම්, මෙයින් අදහස් කරන්නේ ඔබ එක් ක්‍රියාකාරකමකින් තවත් ක්‍රියාකාරකමක් වෙත විශාල මූලද්‍රව්‍යයක් මාරු කිරීමෙන් බන්ධන ගනුදෙනු බෆරය ඉක්මවා යන බවයි.

එබැවින් එවැනි අවස්ථාවකදී ඔබට බිට්මැප් බයිට් අරා ලෙස සම්පීඩනය කර වෙනත් ක්‍රියාකාරකමකින් එය සම්පීඩනය කළ යුතුය මේ වගේ,

පළමු ක්‍රියාකාරිත්වයේ

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);

සහ දෙවන ක්‍රියාකාරිත්වයේ

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

Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

ඔබට එය වෙනත් ක්‍රියාකාරකමකින් ලබා ගත හැකිය. ක්‍රම දෙකක්:

int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);

දෙවන ක්‍රමය නම්:

Intent i = getIntent();
String name = i.getStringExtra("name");

මෙන්න මගේ හොඳම පුහුණුව වන අතර ව්‍යාපෘතිය විශාල හා සංකීර්ණ වූ විට එය බොහෝ සෙයින් උපකාරී වේ.

මට ක්‍රියාකාරකම් 2 ක් ඇතැයි සිතමු, LoginActivityසහ HomeActivity. මම සිට 2 පරාමිතීන් (පරිශීලක නාමය සහ මුරපදය) ලබාදීමට අවශ්ය LoginActivityකිරීමට HomeActivity.

පළමුව, මම මගේ නිර්මාණය 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);
    }
}

මෙන්න මම මගේ පිවිසුම් ක්‍රියාකාරිත්වයේ දත්ත සම්මත කරන ආකාරය

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

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());
    }
}

කළා! සිසිල් :) මට මගේ අත්දැකීම් බෙදා ගැනීමට අවශ්‍යයි. ඔබ කුඩා ව්‍යාපෘතියක වැඩ කරන්නේ නම් මෙය විශාල ගැටළුවක් නොවිය යුතුය. නමුත් ඔබ විශාල ව්‍යාපෘතියක වැඩ කරන විට, නැවත ප්‍රතිනිර්මාණය කිරීම හෝ දෝෂ නිවැරදි කිරීම අවශ්‍ය විට එය සැබවින්ම වේදනාකාරී වේ.

අතිරේක පිළිතුර: යතුරු නූල සඳහා සම්මුති නම් කිරීම

දත්ත සම්ප්‍රේෂණය කිරීමේ සත්‍ය ක්‍රියාවලියට දැනටමත් පිළිතුරු ලැබී ඇත, කෙසේ වෙතත් බොහෝ පිළිතුරු අභිප්‍රායෙහි ප්‍රධාන නම සඳහා දෘඩ කේත කරන ලද නූල් භාවිතා කරයි. ඔබගේ යෙදුම තුළ පමණක් භාවිතා කරන විට මෙය සාමාන්‍යයෙන් හොඳයි. කෙසේ වෙතත්, ප්‍රලේඛනය නිර්දේශ කරන්නේEXTRA_* ප්‍රමිතිගත දත්ත වර්ග සඳහා නියතයන් .

උදාහරණ 1: Intent.EXTRA_*යතුරු භාවිතා කිරීම

පළමු ක්‍රියාකාරකම

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

දෙවන ක්‍රියාකාරකම:

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

උදාහරණ 2: ඔබේම දෑ නිර්වචනය කිරීම static final යතුර

Intent.EXTRA_*නූල් වලින් එකක් ඔබගේ අවශ්‍යතාවන්ට නොගැලපේ නම්, පළමු ක්‍රියාකාරකම ආරම්භයේදීම ඔබට ඔබේම අර්ථ දැක්විය හැකිය.

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

ඔබ ඔබේම යෙදුමේ යතුර පමණක් භාවිතා කරන්නේ නම් පැකේජයේ නම ඇතුළත් කිරීම සම්මුතියක් පමණි. නමුත් ඔබ වෙනත් යෙදුමක් අභිප්‍රාය සමඟ ඇමතිය හැකි යම් සේවාවක් නිර්මාණය කරන්නේ නම් ගැටුම් නම් නොකිරීමේ අවශ්‍යතාවයකි.

පළමු ක්‍රියාකාරකම:

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

දෙවන ක්‍රියාකාරකම:

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

උදාහරණ 3: සංගීත සම්පත් යතුරක් භාවිතා කිරීම

ප්‍රලේඛනයේ සඳහන් නොවූවත්, මෙම පිළිතුර ක්‍රියාකාරකම් අතර පරායත්තතාවයන් වළක්වා ගැනීම සඳහා සංගීත සම්පතක් භාවිතා කිරීම නිර්දේශ කරයි.

strings.xml

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

පළමු ක්‍රියාකාරකම

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

දෙවන ක්‍රියාකාරකම

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

ඔයාට පාවිච්චි කරන්න පුළුවන් Intent

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

තවත් ක්‍රමයක් වන්නේ සිංගල්ටන් රටාව භාවිතා කිරීමයි :

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;
 }
}

ඔබගේ පළමු ක්‍රියාකාරකමෙන්

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

දෙවන ක්‍රියාකාරිත්වය මත

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

ක්‍රියාකාරකම් අතර දත්ත සම්ප්‍රේෂණය කිරීම ප්‍රධාන වශයෙන් සිදුවන්නේ අභිප්‍රාය වස්තුවක් මගිනි.

පළමුව ඔබ Bundleපන්තියේ භාවිතය සමඟ අභිප්‍රාය වස්තුවට දත්ත ඇමිණිය යුතුය . ඉන්පසු ක්‍රම startActivity()හෝ startActivityForResult()ක්‍රම භාවිතා කර ක්‍රියාකාරකම අමතන්න .

බ්ලොග් පෝස්ට් එකකින් උදාහරණයක් ලෙස ක්‍රියාකාරකමකට දත්ත යැවීමෙන් ඔබට ඒ පිළිබඳ වැඩි විස්තර සොයාගත හැකිය .

ඔබට හවුල් මනාපය උත්සාහ කළ හැකිය, එය ක්‍රියාකාරකම් අතර දත්ත හුවමාරු කර ගැනීම සඳහා හොඳ විකල්පයක් විය හැකිය

සැසි හැඳුනුම්පත සුරැකීමට -

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

ඒවා ලබා ගැනීමට -

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

මෙම ක්‍රියාකාරකම් වලින් තවත් ක්‍රියාකාරකමක් ආරම්භ කරන්න පරාමිති බණ්ඩල් වස්තුව හරහා

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);

වෙනත් ක්‍රියාකාරකමක් ලබා ගන්න (ඔබේ ක්‍රියාකාරිත්වය)

String s = getIntent().getStringExtra("USER_NAME");

සරල ආකාරයේ දත්ත වර්ග සඳහා මෙය හරි ය. නමුත් ඔබට ක්‍රියාකාරකම් අතර සංකීර්ණ දත්ත යැවීමට අවශ්‍ය නම් එය පළමුව අනුක්‍රමිකකරණය කළ යුතුය.

මෙන්න අපට සේවක ආකෘතියක් ඇත

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

මෙවැනි සංකීර්ණ දත්ත අනුක්‍රමික කිරීම සඳහා ඔබට ගූගල් විසින් සපයන ලද Gson lib භාවිතා කළ හැකිය

String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);

Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
            Gson gson = new Gson();
            Type type = new TypeToken<Employee>() {
            }.getType();
            Employee selectedEmp = gson.fromJson(empStr, type);

කොට්ලින්

පළමු ක්‍රියාකාරකමෙන් සමත් වන්න

val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)

දෙවන ක්‍රියාකාරකම ලබා ගන්න

val value = getIntent().getStringExtra("key")

යෝජනාව

වඩාත් කළමනාකරණය කළ හැකි ක්‍රම සඳහා යතුරු නිරන්තර ගොනුවේ තබන්න.

companion object {
    val KEY = "key"
}

/*
 * 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));
    }
}

චාලි කොලින්ස් මට පරිපූර්ණ දුන් පිළිතුර භාවිතා Application.class. අපට එය පහසුවෙන් උපවර්ගය කළ හැකි බව මා දැන සිටියේ නැත. අභිරුචි යෙදුම් පන්තියක් භාවිතා කරමින් සරල කළ උදාහරණයක් මෙන්න.

AndroidManifest.xml

android:nameඔබේම යෙදුම් පන්තියක් භාවිතා කිරීමට ගුණාංගය දෙන්න .

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

MyApplication.java

මෙය ගෝලීය යොමු දරන්නෙකු ලෙස භාවිතා කරන්න. එකම ක්‍රියාවලියක් තුළ එය හොඳින් ක්‍රියාත්මක වේ.

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

යෙදුම් උදාහරණයට ගෝලීය “සිංගල්ටන්” යොමුව සකසන්න.

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

වෙනත් ක්‍රියාකාරකමකින් මම ප්‍රධාන ක්‍රියාකාරකමක් භාවිතා කරන සරල උදාහරණයක්.

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();
        }
    }
}

මම මෑතකදී Vapor API , jQuery රස කළ ඇන්ඩ්‍රොයිඩ් රාමුවක් නිකුත් කළෙමි . සඳහන් කළ පරිදි, SharedPreferencesඔබට මෙය කළ හැකි එක් ක්‍රමයකි.

VaporSharedPreferencesඑය එක් විකල්පයක් වන සිංගල්ටන් ලෙස ක්‍රියාත්මක වන අතර වාෂ්ප ඒපීඅයි හි එය අධික ලෙස පටවන ලද .put(...)ක්‍රමයක් ඇත, එබැවින් ඔබ සිදුකරන දත්ත සමුදාය ගැන පැහැදිලිව කරදර විය යුතු නැත - එයට සහාය ලබා දීම. එය ද චතුර ලෙස ක්‍රියාත්මක වන බැවින් ඔබට ඇමතුම් දාම කළ හැකිය:

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

එය විකල්පයන් ස්වයංක්‍රීයව වෙනස් කරන අතර කියවීමේ හා ලිවීමේ ක්‍රියාවලිය යටින් ඒකාබද්ධ කරයි, එබැවින් සම්මත ඇන්ඩ්‍රොයිඩ් වල මෙන් ඔබ සංස්කාරකයක් පැහැදිලිව ලබා ගැනීමට අවශ්‍ය නොවේ.

විකල්පයක් ලෙස ඔබට භාවිතා කළ Intentහැකිය. වාෂ්ප ඒපීඅයි හි ඔබට දාම කළ හැකි අධි බර පැටවීමේ .put(...)ක්‍රමය භාවිතා කළ හැකිය VaporIntent:

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

අනෙක් පිළිතුරු වල සඳහන් පරිදි එය අතිරේක ලෙස සම්මත කරන්න. ඔබට ඔබගේ අමතර දේ ලබා ගත හැකි අතර Activity, තවද ඔබ මෙය භාවිතා VaporActivityකරන්නේ නම් ස්වයංක්‍රීයව ඔබ වෙනුවෙන් මෙය සිදු වේ එවිට ඔබට භාවිතා කළ හැකිය:

this.extras()

Activityඔබ මාරු වන අනෙක් කෙළවරේ ඒවා ලබා ගැනීමට .

සමහරුන්ට උනන්දුවක් දක්වන බලාපොරොත්තුව :)

පළමු ක්‍රියාකාරකම:

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

දෙවන ක්‍රියාකාරකම:

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

යෙදුමේ ක්‍රියාකාරකම් අතර දත්ත ඔබට ක්‍රම 3 කින් සම්මත කළ හැකිය

1. අභිප්රාය
2. SharedPreferences
3. අයදුම්පත

අභිප්‍රායයෙන් දත්ත යැවීම යම් සීමාවක් ඇත. විශාල දත්ත ප්‍රමාණයක් සඳහා ඔබට යෙදුම් මට්ටමේ දත්ත හුවමාරුව භාවිතා කළ හැකි අතර එය SharedPreference හි ගබඩා කිරීමෙන් ඔබගේ යෙදුම් ප්‍රමාණය වැඩි කරයි

ගෝලීය පන්තියක් භාවිතා කරන්න:

public class GlobalClass extends Application
{
    private float vitamin_a;


    public float getVitaminA() {
        return vitamin_a;
    }

    public void setVitaminA(float vitamin_a) {
        this.vitamin_a = vitamin_a;
    }
}

ඔබට අනෙකුත් සියලුම පන්ති වලින් මෙම පන්තියේ කට්ටල සහ ලබා ගන්නන් අමතන්න. එසේ කරන්න, ඔබ සෑම ක්‍රියාකාරකමකදීම ග්ලෝබල් ක්ලාස්-වස්තුවක් සෑදිය යුතුය:

GlobalClass gc = (GlobalClass) getApplication();

එවිට ඔබට උදාහරණයක් ලෙස ඇමතිය හැකිය:

gc.getVitaminA()