hunk.code_window:           mimeType = "*/*";
           }
         }
         Intent intent = Intent.createChooser(createSharingIntent(contentUri, mimeType), params.getString(DIALOG_TITLE_OPTIONS_KEY));
         mModuleRegistry.getModule(ActivityProvider.class).getCurrentActivity().startActivityForResult(intent, REQUEST_CODE);
         mPendingPromise = promise;
       } catch (InvalidArgumentException e) {
  
hunk.labels: keep keep keep keep add keep keep keep keep
hunk.after_edit:       List<ResolveInfo> resInfoList = mContext.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
         for (ResolveInfo resolveInfo : resInfoList) {
           String packageName = resolveInfo.activityInfo.packageName;
           mContext.grantUriPermission(packageName, contentUri, Intent.FLAG_GRANT_READ_URI_PERMISSION);
         }
  
hunk.file_path: packages/expo-sharing/android/src/main/java/expo/modules/sharing/SharingModule.java
hunk.type: add
file: /*=============================================================================
      Copyright (c) 2005-2010 Joel de Guzman
      Copyright (c) 2010 Eric Niebler
      Copyright (c) 2010 Thomas Heller
      Copyright (c) 2014 John Fletcher
  
      Distributed under the Boost Software License, Version 1.0. (See accompanying
      file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  ==============================================================================*/
  #ifndef BOOST_PHOENIX_CORE_ACTOR_HPP
  #define BOOST_PHOENIX_CORE_ACTOR_HPP
  
  #include <boost/phoenix/core/limits.hpp>
  
  #include <boost/is_placeholder.hpp>
  #include <boost/mpl/identity.hpp>
  #include <boost/mpl/eval_if.hpp>
  #include <boost/phoenix/core/domain.hpp>
  #include <boost/phoenix/core/environment.hpp>
  #include <boost/phoenix/core/is_nullary.hpp>
  #include <boost/phoenix/core/meta_grammar.hpp>
  #include <boost/phoenix/support/iterate.hpp>
  #include <boost/phoenix/support/vector.hpp>
  #include <boost/proto/extends.hpp>
  #include <boost/proto/make_expr.hpp>
  #include <boost/utility/result_of.hpp>
  #include <boost/mpl/void.hpp>
  #include <cstring>
  #ifndef BOOST_PHOENIX_NO_VARIADIC_ACTOR
  #   include <boost/mpl/if.hpp>
  #   include <boost/type_traits/is_reference.hpp>
  #   include <boost/phoenix/core/detail/index_sequence.hpp>
  #endif
  
  #ifdef BOOST_MSVC
  #pragma warning(push)
  #pragma warning(disable: 4522) // 'this' used in base member initializer list
  #pragma warning(disable: 4510) // default constructor could not be generated
  #pragma warning(disable: 4610) // can never be instantiated - user defined cons
  #endif
  
  namespace boost { namespace phoenix
  {
      template <typename Expr>
      struct actor;
  
      namespace detail
      {
          struct error_expecting_arguments
          {
              template <typename T>
              error_expecting_arguments(T const&) {}
          };
  
          struct error_invalid_lambda_expr
          {
              template <typename T>
              error_invalid_lambda_expr(T const&) {}
          };
  
          template <typename T>
          struct result_type_deduction_helper
          {
              typedef T const & type;
          };
  
          template <typename T>
          struct result_type_deduction_helper<T &>
          {
              typedef T & type;
          };
  
          template <typename T>
          struct result_type_deduction_helper<T const &>
          {
              typedef T const & type;
          };
  
          struct do_assign
          {
              BOOST_PROTO_CALLABLE()
  
              typedef void result_type;
  
              template <typename T1, typename T2>
              void operator()(T1 & t1, T2 const & t2) const
              {
                  proto::value(t1) = proto::value(t2);
              }
          };
  
  #ifdef BOOST_PHOENIX_NO_VARIADIC_ACTOR
          #include <boost/phoenix/core/detail/cpp03/assign.hpp>
  #else
          struct assign : proto::transform<assign>
          {
              typedef assign proto_grammer;
  
              template <typename Expr, typename State, typename Data
                      , typename Indices = typename detail::make_index_sequence<proto::arity_of<Expr>::value>::type >
              struct impl;
  
              template <std::size_t>
              struct proto_expr { typedef proto::_ type; };
  
              template <std::size_t Index>
              struct nth_assign
              {
                  typedef
                      assign type(
                          proto::_child_c<Index>
                        , proto::call<proto::_child_c<Index>(proto::_state)>
                      )
                  ;
              };
  
              template <typename Expr, typename State, typename Data>
              struct impl<Expr, State, Data, detail::index_sequence<> >
                  : proto::when<
                      proto::terminal<proto::_>
                    , do_assign(proto::_, proto::_state)
                  >::template impl<Expr, State, Data>
              {
              };
  
              template <typename Expr, typename State, typename Data
                      , std::size_t... Indices>
              struct impl<Expr, State, Data, detail::index_sequence<Indices...> >
                  : proto::when<
                      proto::nary_expr<typename proto_expr<Indices>::type...>
                    , proto::and_<typename nth_assign<Indices>::type...>
                  >::template impl<Expr, State, Data>
              {
              };
          };
  #endif
      }
  
      namespace result_of
      {
  #ifdef BOOST_PHOENIX_NO_VARIADIC_ACTOR
          // Bring in the result_of::actor<>
          #include <boost/phoenix/core/detail/cpp03/actor_result_of.hpp>
  #else
          template <typename Expr, typename... A>
          struct actor_impl
          {
              typedef
                  typename boost::phoenix::evaluator::impl<
                      Expr const&
                    , vector2<
                          typename vector_chooser<sizeof...(A) + 1>::
                            template apply<const ::boost::phoenix::actor<Expr> *, A...>::type&
                        , default_actions
                      > const &
                    , proto::empty_env
                  >::result_type
                  type;
          };
  
          template <typename Expr, typename... A>
          struct actor : actor_impl<Expr, A...> {};
  
          template <typename Expr>
          struct nullary_actor_result : actor_impl<Expr> {};
  #endif
  
          template <typename Expr>
          struct actor<Expr>
          {
              typedef
                  // avoid calling result_of::actor when this is false
                  typename mpl::eval_if_c<
                      result_of::is_nullary<Expr>::value
                    , nullary_actor_result<Expr>
                    , mpl::identity<detail::error_expecting_arguments>
                  >::type
              type;
          };
      }
  
      ////////////////////////////////////////////////////////////////////////////
      //
      //  actor
      //
      //      The actor class. The main thing! In phoenix, everything is an actor
      //      This class is responsible for full function evaluation. Partial
      //      function evaluation involves creating a hierarchy of actor objects.
      //
      ////////////////////////////////////////////////////////////////////////////
      template <typename Expr>
      struct actor
      {
          typedef typename
              mpl::eval_if_c<
                  mpl::or_<
                      is_custom_terminal<Expr>
                    , mpl::bool_<is_placeholder<Expr>::value>
                  >::value
                , proto::terminal<Expr>
                , mpl::identity<Expr>
              >::type
              expr_type;
  
          BOOST_PROTO_BASIC_EXTENDS(expr_type, actor<expr_type>, phoenix_domain)
  
          // providing operator= to be assignable
          actor& operator=(actor const& other)
          {
              detail::assign()(*this, other);
              return *this;
          }
          actor& operator=(actor & other)
          {
              detail::assign()(*this, other);
              return *this;
          }
  
          template <typename A0>
          typename proto::result_of::make_expr<
              proto::tag::assign
            , phoenix_domain
            , proto_base_expr
            , A0
          >::type const
          operator=(A0 const & a0) const
          {
              return proto::make_expr<proto::tag::assign, phoenix_domain>(this->proto_expr_, a0);
          }
  
          template <typename A0>
          typename proto::result_of::make_expr<
              proto::tag::assign
            , phoenix_domain
            , proto_base_expr
            , A0
          >::type const
          operator=(A0 & a0) const
          {
              return proto::make_expr<proto::tag::assign, phoenix_domain>(this->proto_expr_, a0);
          }
  
          template <typename A0>
          typename proto::result_of::make_expr<
              proto::tag::subscript
            , phoenix_domain
            , proto_base_expr
            , A0
          >::type const
          operator[](A0 const & a0) const
          {
              return proto::make_expr<proto::tag::subscript, phoenix_domain>(this->proto_expr_, a0);
          }
  
          template <typename A0>
          typename proto::result_of::make_expr<
              proto::tag::subscript
            , phoenix_domain
            , proto_base_expr
            , A0
          >::type const
          operator[](A0 & a0) const
          {
              return proto::make_expr<proto::tag::subscript, phoenix_domain>(this->proto_expr_, a0);
          }
  
          template <typename Sig>
          struct result;
  
          typename result_of::actor<proto_base_expr>::type
          operator()()
          {
              typedef vector1<const actor<Expr> *> env_type;
              env_type env = {this};
  
              return phoenix::eval(*this, phoenix::context(env, default_actions()));
          }
  
          typename result_of::actor<proto_base_expr>::type
          operator()() const
          {
              typedef vector1<const actor<Expr> *> env_type;
              env_type env = {this};
  
              return phoenix::eval(*this, phoenix::context(env, default_actions()));
          }
  
          template <typename Env>
          typename evaluator::impl<
              proto_base_expr const &
            , typename result_of::context<
                  Env const &
                , default_actions const &
              >::type
            , proto::empty_env
          >::result_type
          eval(Env const & env) const
          {
              return phoenix::eval(*this, phoenix::context(env, default_actions()));
          }
  
  #ifdef BOOST_PHOENIX_NO_VARIADIC_ACTOR
          // Bring in the rest
          #include <boost/phoenix/core/detail/cpp03/actor_operator.hpp>
  #else
          template <typename This, typename... A>
          struct result<This(A...)>
              : result_of::actor<
                  proto_base_expr
                , typename mpl::if_<is_reference<A>, A, A const &>::type...
              >
          {};
  
          template <typename... A>
          typename result<actor(A...)>::type
          operator()(A &&... a)
          {
              typedef
                  typename vector_chooser<sizeof...(A) + 1>::template apply<
                      const actor<Expr> *
                    , typename mpl::if_<is_reference<A>, A, A const &>::type...
                  >::type
              env_type;
  
              env_type env = {this, a...};
              return phoenix::eval(*this, phoenix::context(env, default_actions()));
          }
  
          template <typename... A>
          typename result<actor(A...)>::type
          operator()(A &&... a) const
          {
              typedef
                  typename vector_chooser<sizeof...(A) + 1>::template apply<
                      const actor<Expr> *
                    , typename mpl::if_<is_reference<A>, A, A const &>::type...
                  >::type
              env_type;
  
              env_type env = {this, a...};
              return phoenix::eval(*this, phoenix::context(env, default_actions()));
          }
  #endif
      };
  }}
  
  namespace boost
  {
      // specialize boost::result_of to return the proper result type
      template <typename Expr>
      struct result_of<phoenix::actor<Expr>()>
          : phoenix::result_of::actor<typename phoenix::actor<Expr>::proto_base_expr>
      {};
  
      template <typename Expr>
      struct result_of<phoenix::actor<Expr> const()>
          : phoenix::result_of::actor<typename phoenix::actor<Expr>::proto_base_expr>
      {};
  }
  
  
  #ifdef BOOST_MSVC
  #pragma warning(pop)
  #endif
  
  #endif
  
  