Android හි startActivityForResult කළමනාකරණය කරන්නේ කෙසේද?


983

මගේ ක්‍රියාකාරකමේදී, මම ප්‍රධාන ක්‍රියාකාරකමෙන් දෙවන ක්‍රියාකාරකමක් අමතන්නෙමි startActivityForResult. මගේ දෙවන ක්‍රියාකාරකම තුළ, මෙම ක්‍රියාකාරකම අවසන් කරන ක්‍රම කිහිපයක් තිබේ (සමහර විට ප්‍රති result ලයක් නොමැතිව), කෙසේ වෙතත්, ඒවායින් එකක් පමණක් ප්‍රති .ලයක් ලබා දෙයි.

උදාහරණයක් ලෙස, ප්‍රධාන ක්‍රියාකාරකමෙන් මම දෙවැන්න අමතන්නෙමි. මෙම ක්‍රියාකාරකම තුළ, මම කැමරාවක් වැනි ජංගම දුරකථනයේ සමහර අංග පරීක්ෂා කරමි. එය නොමැති නම් මම මෙම ක්‍රියාකාරකම වසා දමමි. එසේම, සකස් කිරීමේදී MediaRecorderහෝ MediaPlayerගැටලුවක් සිදුවුවහොත් මම මෙම ක්‍රියාකාරකම වසා දමමි.

එහි උපාංගයට කැමරාවක් තිබේ නම් සහ පටිගත කිරීම සම්පුර්ණයෙන්ම සිදු කර ඇත්නම්, වීඩියෝවක් පටිගත කිරීමෙන් පසුව පරිශීලකයෙකු විසින් සිදු කරන ලද බොත්තම ක්ලික් කළහොත් ප්‍රති result ලය (පටිගත කළ වීඩියෝවේ ලිපිනය) නැවත ප්‍රධාන ක්‍රියාකාරකමට යවමි.

ප්‍රධාන ක්‍රියාකාරකමේ ප්‍රති result ලය මා පරීක්ෂා කරන්නේ කෙසේද?


Answers:


2481

ඔබගේ FirstActivityඇමතුමෙන් SecondActivityභාවිතා startActivityForResult()කිරීමේ ක්‍රමය

උදාහරණයක් වශයෙන්:

int LAUNCH_SECOND_ACTIVITY = 1
Intent i = new Intent(this, SecondActivity.class);
startActivityForResult(i, LAUNCH_SECOND_ACTIVITY);

ඔබගේ SecondActivityකට්ටලය තුළ ඔබට නැවත ආපසු යාමට අවශ්‍ය දත්ත FirstActivity. ඔබට ආපසු යාමට අවශ්‍ය නැතිනම්, කිසිවක් සකසන්න එපා.

උදාහරණයක් ලෙස: SecondActivityඔබට දත්ත ආපසු යැවීමට අවශ්‍ය නම්:

Intent returnIntent = new Intent();
returnIntent.putExtra("result",result);
setResult(Activity.RESULT_OK,returnIntent);
finish();

ඔබට දත්ත ආපසු ලබා දීමට අවශ්‍ය නැතිනම්:

Intent returnIntent = new Intent();
setResult(Activity.RESULT_CANCELED, returnIntent);
finish();

දැන් ඔබේ FirstActivityපන්තියේදී onActivityResult()ක්‍රමවේදය සඳහා පහත කේතය ලියන්න .

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

    if (requestCode == LAUNCH_SECOND_ACTIVITY) {
        if(resultCode == Activity.RESULT_OK){
            String result=data.getStringExtra("result");
        }
        if (resultCode == Activity.RESULT_CANCELED) {
            //Write your code if there's no result
        }
    }
}//onActivityResult

ක්‍රියාකාරකම් දෙකක් අතර දත්ත හුවමාරු කිරීම කොට්ලින්හි වඩා හොඳ ආකාරයකින් ක්‍රියාත්මක කිරීමට කරුණාකර මෙම සබැඳිය හරහා ගොස් ' ක්‍රියාකාරකම් අතර දත්ත සම්ප්‍රේෂණය කිරීමට වඩා හොඳ ක්‍රමයක් '


1
RESUT_CANCELLED setResult (RESULT_CANCELED, returnIntent) හි අභිප්‍රාය තැබීමේ අරමුණ කුමක්ද;
ඉස්මයිල් සහින්

4
තුළ සිතන්න @ismail SecondActivityසමහර ව්යතිරේකයක්, එම නඩුව ද ඔබ වෙත ප්රතිඵලයක් යන්න ඕනේ FirstActivityඔබ ප්රතිඵලය සකස් කළ හැකි නිසා, "RESULT_CANCELLED"කිරීමට අතට උඩ පන්දුවක් වාරණ හා ආපසු FirstActivtyසහ FirstActivity's' 'onActivityResult()ඔබ සාර්ථකත්වය හෝ අසාර්ථකත්වය නිසා විය යන්න පරීක්ෂා කළ හැකියි.
නිශාන්ත්

10
එබැවින් එය ඔබට භාරයි, අවලංගු කිරීමට හේතුව දැන ගැනීමට ඔබට අවශ්‍ය නැතිනම්, ඔබට setResult (RESULT_CANCELED) භාවිතා කළ හැකිය; කිසිදු අභිප්‍රායයකින් තොරව
ඉස්මයිල් සහින්

2
EALei Leyba startActivityForResult () ඇමතීමෙන් පසු කිසිදු නිමාවක් () කැඳවනු නොලැබේ. පළමු ක්‍රියාකාරකම තත්වය විරාමයක් කරා ගමන් කරයි.
නිශාන්ත්

6
මට නම් එය ක්‍රියාත්මක නොවේ -.- මෙය මම ඇන්ඩ්‍රොයිඩ් ගැන බොහෝ සෙයින් වෛර කරමි - මෙම ක්‍රමය එතරම් විශ්වාසදායක නොවේ: - /
මාටින් පෆෙෆර්

51

ප්රධාන ක්රියාකාරිත්වයේ ප්රති result ලය පරීක්ෂා කරන්නේ කෙසේද?

ඔබ අභිබවා Activity.onActivityResult()ගොස් එහි පරාමිතීන් පරීක්ෂා කරන්න:

  • requestCodeමෙම ප්‍රති .ල ලබා දුන් යෙදුම හඳුනා ගනී. ඔබ අමතන විට මෙය ඔබ විසින් අර්ථ දක්වනු ලැබේ startActivityForResult().
  • resultCode මෙම යෙදුම සාර්ථකද, අසමත්ද, හෝ වෙනස් දෙයක්ද යන්න ඔබට දන්වයි
  • dataමෙම යෙදුම මඟින් ආපසු ලබා දෙන ඕනෑම තොරතුරක් දරයි. මෙය විය හැකිය null.

එහි අර්ථය වන්නේ requestCode පළමු ක්‍රියාකාරකම සඳහා පමණක් භාවිතා වන අතර එය 2 වන ක්‍රියාකාරකම සඳහා කිසි විටෙකත් භාවිතා නොකරන බවයි? 2 වන ක්‍රියාකාරකමට වෙනස් ප්‍රවේශයන් තිබේ නම්, එය වෙනස් වනු ඇත, නමුත් අභිප්‍රාය අතිරේක මත පදනම්ව මිස ඉල්ලීම් කේතය මගින් නොවේ, හරිද? සංස්කරණය කරන්න: ඔව්, stackoverflow.com/questions/5104269/…
JCarlosR

46

උදාහරණයක්

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

රූප විස්තරය මෙහි ඇතුළත් කරන්න

MainActivity.java

public class MainActivity extends AppCompatActivity {

    // Add a different request code for every activity you are starting from here
    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) { // Activity.RESULT_OK

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

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

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("keyName", stringToPassBack);
        setResult(RESULT_OK, intent);
        finish();
    }
}

A සහ app b යන යෙදුම් දෙකකින් මෙය කළ හැකිද? stackoverflow.com/questions/52975645/…
ජෙරී ඒබ්‍රහම්

45

@ නිශාන්තගේ පිළිතුරට අනුපූරකව, ක්‍රියාකාරකම් ප්‍රති result ලය ලබා දිය හැකි හොඳම ක්‍රමය:

Intent returnIntent = getIntent();
returnIntent.putExtra("result",result);
setResult(RESULT_OK,returnIntent);
finish();

මට ගැටලුවක් තිබුණා

new Intent();

එවිට මම දැනගත්තා නිවැරදි ක්‍රමය භාවිතා කරන බව

getIntent();

වත්මන් අභිප්රාය ලබා ගැනීමට


ක්‍රියාවක් හෝ අංගයක් වැනි සාමාන්‍ය අගයන් නොමැති, Intentරඳවා තබා ගැනීමට පමණක් පවතින නව දෙයක් නිර්මාණය කිරීම තරමක් අමුතු දෙයක් ලෙස හැඟේ Bundle. නමුත් Intentවර්තමාන ක්‍රියාකාරකම් දියත් කිරීම සඳහා භාවිතා කළ දේ වෙනස් කිරීම තරමක් අමුතු (හා භයානක විය හැකිද?) දැනේ . ඒ නිසා මම ඇන්ඩ්‍රොයිඩ් සඳහාම ප්‍රභවය සෙවූ අතර ඔවුන් සෑම විටම ප්‍රති Intent.ලයක් ලෙස භාවිතා කිරීමට නව දෙයක් නිර්මාණය කරන බව සොයා ගත්තා . උදාහරණයක් ලෙස, github.com/aosp-mirror/platform_frameworks_base/blob/…
spaaarky21

හෙලෝ spaaarky21, ඔබගේ අදහස් දැක්වීමට ස්තූතියි. මට කණගාටුයි, මම එම විසඳුම සමඟ අවසන් වූයේ කෙසේද යන්න පැහැදිලි කිරීමේදී මා එතරම් පැහැදිලි නොවීය. එය මීට වසර තුනකට පෙර වූ අතර මට මතක තබා ගත හැක්කේ "නව අභිප්‍රාය" නිසා මගේ යෙදුම බිඳ වැටී ඇති බව පමණි, "මට ගැටලුවක් තිබේ" යැයි පැවසූ විට මා අදහස් කළේ එයයි. ඇත්තටම මම "getIntent" සමඟ උත්සාහ කළෙමි, මන්ද එය එකල අර්ථවත් වූ අතර එය ක්‍රියාත්මක විය! ඒ නිසා මම මගේ විසඳුම බෙදා ගැනීමට තීරණය කළෙමි. "හොඳම ක්‍රමය" හෝ "නිවැරදි මාර්ගය" යැයි පැවසීමට හොඳම වචන තේරීම නොවන්නට පුළුවන, නමුත් මම මගේ විසඳුම වෙනුවෙන් පෙනී සිටිමි. එය මගේ ගැටලුව විසඳූ අතර පෙනෙන ආකාරයට අනෙක් පුද්ගලයින් ද වේ. ස්තූතියි
ජූලියන් ඇල්බර්ටෝ

1
වාව්! නියමයි. getIntent()ක්‍රියාකාරකම හැඳින්වූ ස්ථානයෙන්, නොදන්නා ක්‍රියාකාරකම් වෙත දත්ත නැවත ලබා දීමට කදිම ක්‍රමයක් ලෙස පෙනේ. ස්තූතියි!
සෑම්

12

සමග ගැටළුවක් ඇති අයට, onActivityResult වැරදි requestCode

ඔබ ඔබගේ ඇමතුමක් startActivityForResult()ලබා ගන්නේ නම් Fragment, ඉල්ලීම් කේතය කැබැල්ල සතු ක්‍රියාකාරකම මගින් වෙනස් කරනු ලැබේ.

ඔබේ ක්‍රියාකාරකමෙහි නිවැරදි ප්‍රති result ල කේතය ලබා ගැනීමට ඔබට අවශ්‍ය නම් මෙය උත්සාහ කරන්න:

වෙනස් කරන්න:

startActivityForResult(intent, 1); වෙත:

getActivity().startActivityForResult(intent, 1);


10

ක්‍රියාකාරකම් ප්‍රති result ල සමඟ පරිශීලක අතුරුමුහුණත යාවත්කාලීන කිරීමට ඔබට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ නොහැක this.runOnUiThread(new Runnable() {} UI කිරීම නව අගයකින් නැවුම් නොකරනු ඇත. ඒ වෙනුවට, ඔබට මෙය කළ හැකිය:

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

    if (resultCode == RESULT_CANCELED) {
        return;
    }

    global_lat = data.getDoubleExtra("LATITUDE", 0);
    global_lng = data.getDoubleExtra("LONGITUDE", 0);
    new_latlng = true;
}

@Override
protected void onResume() {
    super.onResume();

    if(new_latlng)
    {
        PhysicalTagProperties.this.setLocation(global_lat, global_lng);
        new_latlng=false;
    }
}

මෙය මෝඩකමක් ලෙස පෙනුනද එය හොඳින් ක්‍රියාත්මක වේ.


2

පළමු ඔබ භාවිතා startActivityForResult()පළමු පරාමිතීන් හා සමග Activityඔබ දෙවන දත්ත යැවීමට අවශ්ය නම් Activityපළමු කිරීමට Activityඑවකට භාවිතා අගය සමත් Intentසමග setResult()ක්රමය සහ ඇතුලත අතර දත්ත ලබා onActivityResult()පළමු ක්රමය Activity.


2

ActivityResultRegistry යනු නිර්දේශිත ප්‍රවේශයයි

ComponentActivityදැන් ලබා ActivityResultRegistryඔබ හැසිරවිය ඉඩ සලසන startActivityForResult()+ onActivityResult()මෙන්ම requestPermissions()+ onRequestPermissionsResult()ආධිපත්යධාරී ඔබේ ක්රම තොරව ගලා Activityහෝ Fragmentහරහා ආකාරයේ ආරක්ෂක ඉහළ ගෙන එයි ActivityResultContract, සහ මෙම ගලා පරීක්ෂා කොකු සපයයි.

AndroidX ක්‍රියාකාරකම් 1.2.0-alpha02 සහ Fragment 1.3.0-alpha02 හි හඳුන්වා දී ඇති ක්‍රියාකාරකම් ප්‍රති ult ල API භාවිතා කිරීම තරයේ නිර්දේශ කෙරේ.

මෙය ඔබගේ වෙත එක් කරන්න build.gradle

def activity_version = "1.2.0-alpha03"

// Java language implementation
implementation "androidx.activity:activity:$activity_version"
// Kotlin
implementation "androidx.activity:activity-ktx:$activity_version"

කලින් සාදන ලද කොන්ත්රාත්තුව භාවිතා කරන්නේ කෙසේද?

මෙම නව API හි පහත සඳහන් පූර්ව සාදන ලද ක්‍රියාකාරකම් ඇත

  1. TakeVideo
  2. PickContact
  3. GetContent
  4. GetContents
  5. OpenDocument
  6. OpenDocuments
  7. OpenDocumentTree
  8. CreateDocument
  9. අමතන්න
  10. පින්තූරයක් ගන්න
  11. ඉල්ලීම් අවසරය
  12. ඉල්ලීම් අවසර

TakePictures කොන්ත්‍රාත්තුව භාවිතා කරන උදාහරණයක්:

private val takePicture = prepareCall(ActivityResultContracts.TakePicture()) { bitmap: Bitmap? ->
    // Do something with the Bitmap, if present
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    button.setOnClickListener { takePicture() }
}

ඉතින් මෙතන මොකද වෙන්නේ? අපි එය තරමක් බිඳ දමමු. takePictureඇමතුමක් ලබා ගැනීම පමණක් කළ නොහැකි බිට්මැප් එකක් - එය ශුන්‍යද නැද්ද යන්න රඳා පවතින්නේ onActivityResultක්‍රියාවලිය සාර්ථකද නැද්ද යන්න මතය . prepareCallඉන්පසු මෙම ඇමතුම නව විශේෂාංගයකට ලියාපදිංචි ComponentActivityකරයි ActivityResultRegistry- අපි පසුව මෙය වෙත පැමිණෙමු. ActivityResultContracts.TakePicture()ගූගල් විසින් අප වෙනුවෙන් නිර්මාණය කර ඇති ගොඩනංවන ලද උදව්කරුවන්ගෙන් එකක් වන අතර, අවසානයේදී ආයාචනා කිරීම takePictureඇත්ත වශයෙන්ම ඔබ කලින් කළ ආකාරයටම අභිප්‍රාය අවුලුවයි Activity.startActivityForResult(intent, REQUEST_CODE).

අභිරුචි කොන්ත්රාත්තුවක් ලියන්නේ කෙසේද?

සරල කොන්ත්‍රාත්තුවක් මඟින් ආදාන ලෙස ආදානයක් ලබාගෙන ක්‍රියාකාරී ඉල්ලීම් කළ නූලක් ප්‍රති result ලයෙන් ලබා දෙයි.

class MyContract : ActivityResultContract<Int, String>() {

    companion object {
        const val ACTION = "com.myapp.action.MY_ACTION"
        const val INPUT_INT = "input_int"
        const val OUTPUT_STRING = "output_string"
    }

    override fun createIntent(input: Int): Intent {
        return Intent(ACTION)
            .apply { putExtra(INPUT_INT, input) }
    }

    override fun parseResult(resultCode: Int, intent: Intent?): String? {
        return when (resultCode) {
            Activity.RESULT_OK -> intent?.getStringExtra(OUTPUT_STRING)
            else -> null
        }
    }
}

class MyActivity : AppCompatActivity() {

    private val myActionCall = prepareCall(MyContract()) { result ->
        Log.i("MyActivity", "Obtained result: $result")
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        ...
        button.setOnClickListener {
            myActionCall(500)
        }
    }
}

වැඩි විස්තර සඳහා මෙම නිල ලේඛනය පරීක්ෂා කරන්න .


1

ඇන්ඩ්‍රොයිඩ් වල ඉතා සුලභ ගැටළුව
එය කොටස් 3 කට බෙදිය හැකිය
1) ආරම්භක ක්‍රියාකාරකම් බී (ක්‍රියාකාරීත්වයේ සිදුවීම A)
2) ඉල්ලූ දත්ත සකසන්න (ක්‍රියාකාරීත්වයේ සිදුවීම් B)
3) ඉල්ලූ දත්ත ලබා ගන්න (ක්‍රියාකාරීත්වයේ A)

1) ආරම්භක ක්‍රියාකාරිත්වය B.

Intent i = new Intent(A.this, B.class);
startActivity(i);

2) ඉල්ලූ දත්ත සකසන්න

මෙම කොටසේදී, යම් සිදුවීමක් සිදු වූ විට ඔබට දත්ත ආපසු යැවීමට අවශ්‍යද නැද්ද යන්න තීරණය කරයි.
උදා: B ක්‍රියාකාරකම් වලදී සංස්කරණ පෙළක් සහ බොත්තම් දෙකක් b1, b2 ඇත.
බොත්තම b1 මත ක්ලික් කිරීමෙන් දත්ත නැවත ක්‍රියාකාරීත්වයට යවනු ලැබේ
බොත්තම b2 මත ක්ලික් කිරීමෙන් කිසිදු දත්තයක් නොයවනු ඇත.

දත්ත යැවීම

b1......clickListener
{
   Intent resultIntent = new Intent();
   resultIntent.putExtra("Your_key","Your_value");
   setResult(RES_CODE_A,resultIntent);
   finish();
}

දත්ත යැවීම නොවේ

b2......clickListener
    {
       setResult(RES_CODE_B,new Intent());
       finish();
    }

පරිශීලකයා පෙර බොත්තම ක්ලික් කරයි
පෙරනිමියෙන්, ප්‍රති result ලය ක්‍රියාකාරකම සමඟ සකසා ඇත. RESULT_CANCEL ප්‍රතිචාර කේතය

3) ප්‍රති .ලය ලබා ගන්න

ඒ සඳහා overActivityResult ක්‍රමය ඉක්මවා යන්න

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

if (resultCode == RES_CODE_A) {

     // b1 was clicked 
   String x = data.getStringExtra("RES_CODE_A");

}
else if(resultCode == RES_CODE_B){

   // b2 was clicked

}
else{
   // back button clicked 
}
}

0
You need to override Activity.onActivityResult()

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

if (resultCode == RESULT_CODE_ONE) {


   String a = data.getStringExtra("RESULT_CODE_ONE");

}
else if(resultCode == RESULT_CODE_TWO){

   // b was clicked

}
else{

}
}

ඔබගේ පිළිතුරට ස්තූතියි, නමුත් ඔබගේ පිළිතුර සහ අනුමත පිළිතුර අතර වෙනස කුමක්ද?
හෙසම්

0

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

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

    findViewById(R.id.takeCam).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent intent=new Intent(getApplicationContext(),TakePhotoActivity.class);
            intent.putExtra("Mode","Take");
            startActivity(intent);
        }
    });
    findViewById(R.id.selectGal).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent intent=new Intent(getApplicationContext(),TakePhotoActivity.class);
            intent.putExtra("Mode","Gallery");
            startActivity(intent);
        }
    });
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

}

පෙන්වීමට දෙවන ක්‍රියාකාරකම තුළ

private static final int CAMERA_REQUEST = 1888;
private ImageView imageView;
private static final int MY_CAMERA_PERMISSION_CODE = 100;
private static final int PICK_PHOTO_FOR_AVATAR = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_take_photo);

    imageView=findViewById(R.id.imageView);

    if(getIntent().getStringExtra("Mode").equals("Gallery"))
    {
        pickImage();
    }
    else {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[]{Manifest.permission.CAMERA}, MY_CAMERA_PERMISSION_CODE);
            } else {
                Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                startActivityForResult(cameraIntent, CAMERA_REQUEST);
            }
        }
    }
}
public void pickImage() {
    Intent intent = new Intent(Intent.ACTION_PICK);
    intent.setType("image/*");
    startActivityForResult(intent, PICK_PHOTO_FOR_AVATAR);
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
{
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == MY_CAMERA_PERMISSION_CODE)
    {
        if (grantResults[0] == PackageManager.PERMISSION_GRANTED)
        {
            Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
            startActivityForResult(cameraIntent, CAMERA_REQUEST);
        }
        else
        {
            Toast.makeText(this, "Camera Permission Denied..", Toast.LENGTH_LONG).show();
        }
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == CAMERA_REQUEST && resultCode == Activity.RESULT_OK) {
        Bitmap photo = (Bitmap) data.getExtras().get("data");
        imageView.setImageBitmap(photo);
    }
        if (requestCode == PICK_PHOTO_FOR_AVATAR && resultCode == Activity.RESULT_OK) {
            if (data == null) {
                Log.d("ABC","No Such Image Selected");
                return;
            }
            try {
                Uri selectedData=data.getData();
                Log.d("ABC","Image Pick-Up");
                imageView.setImageURI(selectedData);
                InputStream inputStream = getApplicationContext().getContentResolver().openInputStream(selectedData);
                Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                Bitmap bmp=MediaStore.Images.Media.getBitmap(getContentResolver(),selectedData);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch(IOException e){

            }
    }
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.