米聊社交游戏API

注意：

在接入米聊社交游戏API之前，先跟商务同学联系，确保您的游戏适合接入米聊社交关系，再继续阅读此文档；
此文档中定义的API仅适合游戏，请软件不要接入米聊社交关系；
若您要接入小米应用内支付，请访问应用内支付接入指南。

快速导航： 下载最新SDK，错误代码，技术FAQ ，运营FAQ，SDK更新记录有任何技术问题，欢迎到游戏开发者论坛吐槽，寻求帮助。

修订记录：

2014/07/23 文档第一稿

米聊社交游戏介绍： 如果您的游戏需要接入米聊的以下属性，即需要接入米聊社交游戏SDK：

用米聊账号玩游戏，并读取好友排行榜
游戏体力相关（赠送、索取、使用、自动恢复）
邀请好友一起玩游戏
发游戏截图或文字到米聊圈子
上传积分、战绩

接入步骤：

注册成为开发者 http://dev.xiaomi.com
创建一个新的移动应用 ( 您将获得AppId / AppKey / AppSecret )
配置应用内支付（应用类型[手机游戏]–>计费类型[计费代码/金额]）
填写《米聊游戏配置文档》，然后发给 game-support@xiaomi.com 申请开通米聊游戏社区API
参考《米聊社交游戏SDK开发指南》进行SDK集成(集成之前可以联系我们商务获取集成建议)
参考《应用内支付接入指南》集成支付SDK
自行测试，提交最终APK到小米开发者站 http://dev.xiaomi.com
审核上线

整体技术架构图： enter image description here 说明：

应用内支付与社交关系SDK在同一个包里；
若接入米聊社交关系，必须使用小米账号登录，即miLogin()
米聊社交关系API中共提供了18个客户端接口，合作伙伴可以根据自己游戏情况决定接入哪些功能。

初始化：

请先获取AppId和AppKey（到开发者站http://dev.xiaomi.com创建应用，并接入应用内支付服务），然后调用下面的SDK初始化代码进行初始化操作。将SDK包中的MiGameCenterSDKService.apk放到应用工程的的assets目录下，SDK的jar包放到工程的libs下，在buildpath中引用，然后对SDK进行初始化。,(注：检查游戏的包名是否与提供给小米后台数据配置的包名一致，appid与appkey是否与申请的一致，如果不一致会导致调用登录和其它SDK接口失败)，请在Application.onCreate中调用以下初始化方法

MiAppInfo appInfo = new MiAppInfo();
appInfo.setAppId("开发者申请获得");
appInfo.setAppKey("开发者申请获得");
appInfo.setOrientation( ScreenOrientation.horizontal ); //横竖屏
MiCommplatform.Init( this, appInfo );

SDK所需要的权限：

< uses-permission android:name="android.permission.GET_TASKS"  />
< uses-permission android:name="com.xiaomi.sdk.permission.PAYMENT" />

接口调用流程图：

接口依赖关系：

1）miLogin()和loadGameInfo()为必须调用接口、调用完这两个接口之后所有的米聊社交API接口都可以调用。

2）在调用useHeart()/updateMe()接口之前必须调用loadGameMe()接口。 3）在调用updateResult()/updateResults()接口之前必须调用useHeart()接口。

4）在调用acceptMessage()/acceptAllMessage()接口之前必须调用loadGameMessage()接口。

5）syncResult()/syncResults()接口是服务器配置的，如需使用请联系游戏接入运营人员。

其它接口依照自己的需求任意调用。 - 完整接入方式：适合休闲类游戏 enter image description here - 简化的接入方式：适合MMORPG游戏

登陆调用miLogin：

MiCommplatform.getInstance().miLogin( context,new OnLoginProcessListener()
{
        @Override
        public void finishLoginProcess( int code, MiAccountInfo arg1 )
        {
             switch( code )
            {
                     case MiErrorCode.MI_XIAOMI_GAMECENTER_SUCCESS:
                                // 登陆成功
                 //获取用户的登陆后的UID（即用户唯一标识）
                  long uid = arg1.getUid();
                               break;
                     case MiErrorCode.MI_XIAOMI_GAMECENTER_ERROR_LOGIN_FAIL:
                               // 登陆失败
                                break;
                     case MiErrorCode.MI_XIAOMI_GAMECENTER_ERROR_CANCEL:
                                // 取消登录
                                break;
         case MiErrorCode.MI_XIAOMI_GAMECENTER_ERROR_ACTION_EXECUTED:   
                 //登录操作正在进行中
                 break;     
         default:
                                // 登录失败
                       break;
          }
    }
} );

loadGameInfo： 读取游戏的配置信息，这些配置信息是区分游戏的，是运营可配置的始化游戏的基本配置。，在游戏启动时，通过此接口初始化游戏的基本配置。

请求参数：无

返回参数：

名称	说明
max_heart	体力上限（通过接收赠送可以突破rechargeable_heart，但是不能突破max_heart）
rechargeable_heart	可充值体力上限
heart_regen_interval	体力恢复间隔，单位秒
game_message_interal	发送赠送体力间隔，单位秒（对同一好友不能连续赠送，需要等待间隔后才能再次赠送）
invitation_interval	发送邀请间隔，单位秒（同上）
invitation_interval	发送邀请间隔，单位秒（同上）
score_reset_wday	分数将在周几重置（Sunday:0 Monday:1……）
score_reset_hour	分数将在哪一个小时重置
next_score_reset_time	距离下次重置还有多少个小时
min_version_for_ios	支持的最低iOS系统版本
min_version_for_android	支持最低Android系统版本
min_version_for_android	支持最低Android系统版本
leaderboards	排行榜(可能会存在多个排行榜)
排行榜包含字段
key	排行榜的标识
name	排行版的名称

MiCommplatform.getInstance().loadGameInfo(GamActivity.this,new MiResponseHandler()
    {
           @Override
        protected void onError( int sdkStatus, JSONObject result )
        {
                alert( GamActivity.this, "onError", "\n sdkstatus:" + sdkStatus );
           }
        @Override
           protected void onComplete( int arg1, JSONObject result )
        {
                  alert( GamActivity.this, "onComplete", "\n sdkstatus:" + arg1 + "\n result:" + result );
                  Log.i("GameInfo","rechargeable_heart:"+result.optString( "rechargeable_heart" ) );
                 Log.i("GameInfo","game_message_interval:"+result.optString( "game_message_interval" ) );
                  Log.i("GameInfo","heart_regen_interval:"+result.optString( "heart_regen_interval" ) );
                Log.i("GameInfo","invitation_interval:"+result.optString( "invitation_interval" ) );
               Log.i( "Game Info", "name: " + result.optString( "name" ) );
               Log.i( "Game Info", "max_heart:" + result.optString("max_heart") );
                  Log.i("GameInfo","score_reset_wday:"+result.optString( "score_reset_wday" ) );
                Log.i("GameInfo","score_reset_hour:"+result.optString( "score_reset_hour" ) );
                  Log.i("GameInfo","next_score_reset_time:"+result.optString( "next_score_reset_time" ) );
                  Log.i("GameInfo","min_version_for_ios:"+result.optString( "min_version_for_ios" ) );
                  Log.i("GameInfo","min_version_for_android:"+result.optString( "min_version_for_android" ) );
                Log.i("GameInfo","current_version_for_ios:"+result.optString( "current_version_for_ios" ) );
                  Log.i("GameInfo","current_version_for_android:"+ result.optString( "current_version_for_android" ) );
                  Log.i( "Game Info", "notice: " + result.optString( "notice" ) );
               JSONArray leaderboards = result.optJSONArray( "leaderboards" );
                  if ( leaderboardKeys != null )
                           leaderboardKeys = new String[0];
                  leaderboardKeys = new String[leaderboards.length()];
            try
                {
                          Log.i( "", "-------- Game leaderboards" );
                        for ( int i = 0; i < leaderboards.length(); i++ )
                        {
                                JSONObject leaderboard = leaderboards.getJSONObject( i );
                                  Log.i( "", "name: " + leaderboard.optString( "name" ) );
                                Log.i( "", "key: " + leaderboard.optString( "key" ) );
                                leaderboardKeys[i] = leaderboard.optString( "key" );
                          }
                  }
                catch ( JSONException e )
                {
                           e.printStackTrace();
                }
        }
    } );

loadGameMe： 读取玩家当前状态。当返回游戏首页时，通过此接口，刷新玩家状态。

请求参数：无

返回参数：

名称	说明
user_id	游戏中心uid
nickname	米聊昵称
profile_image_url	米聊头像地址
exp	当前总经验值
heart	当前体力
heart_regen_starts_at	体力恢复起始时间
message_blocked	是否不接收体力（如果用户开启了这项，他的朋友无法向他赠送体力。我们第一期可以不实现这个功能，仅保留这个字段，取值始终是false）
message_count	当前未接收体力条数，读取具体哪些体力未领取，是单独接口。
private_data	私有附加存储数据（仅本账号可见的附加存储数据，CP可用来记录玩家的道具数量、货币数量等）
public_data	公开附加存储数据（好友们可见的附加存储数据，CP可用来记录签名、勋章、avatar等。比如我在游戏里换了时装，我的好友就能看得到。）
scores	分数(一个游戏可能会有多个排行榜，比如按照获取金币排行、按照飞行距离排行、按照击杀怪物排行，所以可能会有多个分数)
分数的数据结构包含以下字段
leaderboard_key	排行榜标识
season_score	本季最高分（一季可能是一周）
last_season_score	上一季最高分
best_score	有史以来最高分
last_score	上次最高分

MiCommplatform.getInstance().loadGameMe( GamActivity.this, new MiResponseHandler()
{
    @Override
    protected void onComplete( int arg0, JSONObject result )
    {
           alert( GamActivity.this, "onComplete", "\n result:" + result );
        Log.i( "", "-------- User Info" );
        Log.i( "", "user_id: " + result.optString( "user_id" ) );
           Log.i( "", "nickname: " + result.optString( "nickname" ) );
        Log.i( "", "profile_image_url: " + result.optString( "profile_image_url" ) );
        Log.i( "", "heart: " + result.optString( "heart" ) );
        currentHeart = Integer.parseInt( result.optString( "heart" ) );
        Log.i( "", "exp: " + result.optString( "exp" ) );
        Log.i("","heart_regen_starts_at:"+result.optString( "heart_regen_starts_at" ) );
        String publicData = result.optString( "public_data" );
        if ( publicData != null )
        {
                Log.i( "", "public_data : after- " + publicData );
                byte[] decoded = Base64.decode( publicData, 0 );
                publicData = new String( decoded );
                Log.i( "", "public_data: before-" + publicData );
        }
        String privateData = result.optString( "private_data" );
        if ( privateData != null )
        {
                Log.i( "", "private_data : after- " + privateData );
                byte[] decoded = Base64.decode( privateData, 0 );
                privateData = new String( decoded );
                Log.i( "", "private_data: before-" + privateData );
        }
        Log.i( "", "message_count: " + result.optString( "message_count" ));
        final String message_block = result.optString( "message_blocked");
        isMessageBlocked = message_block.equals( "1" );
        Log.i( "", "message_blocked: " + isMessageBlocked );
        JSONArray scores = result.optJSONArray( "scores" );
        Log.i( "", "-------- Score Info" );
        try
        {
                for ( int i = 0; i < scores.length(); i++ )
                {
                    JSONObject score = scores.getJSONObject( i );
                    Log.i("","leaderboard_key:"+score.optString( "leaderboard_key" ) );
                    Log.i( "", "season_score: " + score.optString( "season_score" ) );
                    Log.i("","last_season_score:"+score.optString( "last_season_score" ) );
                    Log.i( "", "last_score: " + score.optString( "last_score" ) );
                    Log.i( "", "best_score: " + score.optString( "best_score" ) );
                }
        }
        catch ( Exception e )
        {
                e.printStackTrace();
        }
    }
    @Override
    protected void onError( int arg0, JSONObject result )
    {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
    }
} );

loadGameFriends： 读取玩家的好友列表及好友信息。好友列表用来展示积分榜、赠送体力、邀请好友。

请求参数：无

返回参数：

名称	说明
friends_count	好友数量
app_friends	已经在玩这款游戏的好友
已玩游戏好友包含以下字段
user_id	游戏中心uid
rank	排名
best_score	最高分
nickname	米聊用户昵称
friend_nickname	用户设置的昵称
profile_image_url	头像地址
message_blocked	好友是否允许赠送体力
last_message_sent_at	最后发消息时间
season_score	本赛季最高分
last_season_score	上个赛季最高分
exp	当前总经验值
public_data	保存的数据
friends	没有玩游戏的好友

MiCommplatform.getInstance().loadGameFriends(GameFriendListActivity.this,new MiResponseHandler()
{
 @Override
 protected void onComplete( int miStatus, JSONObject result )
 {
 if ( !result.has( "app_friends" ))
 {
 Log.i( TAG, "friends info is null." );
 return;
 }
 JSONArray appFriendArray = result.optJSONArray( "app_friends");
 if ( appFriendArray.length() == 0 && friendArray.length() == 0 )
 MessageUtil.alert( GameFriendListActivity.this, "no friends" );
 appFriends.clear();
 Log.i( "", "-------- app friends" );
 for ( int i = 0, n = appFriendArray.length(); i < n; i++ )
 {
 JSONObject friend = appFriendArray.optJSONObject( i );
 if ( friend != null )
 {
 appFriends.add( friend );
 Log.i( "", "-------- app_friends[" + i + "]" );
 Log.i( "", "rank: " + friend.optString( "rank" ));
 Log.i( "", "user_id: " + friend.optString( "user_id" ) );
 Log.i( "", "nickname: " + friend.optString( "nickname" ));
 Log.i("","profile_image_url:"+friend.optString( "profile_image_url" ) );
 Log.i("","friend_nickname:"+friend.optString("friend_nickname" ));
 Log.i("","message_blocked:"+friend.optString( "message_blocked" ) );
 Log.i("","last_message_sent_at:"+friend.optString( "last_message_sent_at" ) );
 Log.i( "", "season_score: " + friend.optString( "season_score" ) );
 Log.i("","last_season_score:"+friend.optString( "last_season_score" ) );
 Log.i( "", "last_score: " + friend.optString( "last_score") );
 Log.i( "", "best_score: " + friend.optString( "best_score" ) );
 Log.i( "", "exp: " + friend.optString( "exp" ) );
 String publicData = friend.optString( "public_data" );
 if ( publicData != null )
 {
 Log.i( "", "public_data : after- " + publicData );
 byte[] decoded = Base64.decode( publicData, 0 );
 publicData = new String( decoded );
 Log.i( "", "public_data: before-" + publicData );
 }
 }
 }
 friendType = FriendInfoType.AppFriends;
 changeList();
 MessageUtil.alert( GameFriendListActivity.this, "onComplete", "sdk Status: " + miStatus + ", result: " + result );
 }
 @Override
 protected void onError( int miStatus, JSONObject result )
 {
 MessageUtil.alert( GameFriendListActivity.this, "onError", "sdkStatus: " + miStatus + ", result: " + result );
 }
} );

loadLeaderBoard： 多个积分榜中读取某一个积分榜的信息

请求参数：

名称	说明
leaderboardKey	某个积分榜的key,通过loadGameInfo接口获取
page	排行榜页码，默认为1
pageCount	每页榜单的条数，默认20，最大值100

返回参数：

名称	说明
leaderboard_key	排行榜的key
total	有积分的好友的总数
app_friends	好友列表
好友列表字段
user_id	游戏中心uid
best_score	最好成绩
season_score	本赛季最高分
last_season_score	上个赛季最高分
rank	排名
nickname	昵称
profile_image_url	头像地址
message_blocked	是否允许赠送体力
exp	当前总经验
public_data	公开附加存储数据
last_message_sent_at	最后消息发送时间

String leaderboardKey;
int page = 1;
Int pageCount = 20;
MiCommplatform.getInstance().loadLeaderBoard(GamActivity.this,leaderboardKey,page,pageCount,new MiResponseHandler()
{
       @Override
       protected void onError( int arg0, JSONObject arg1 )
    {
             alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
       }
       @Override
       protected void onComplete( int arg0, JSONObject arg1 )
    {
              alert( GamActivity.this, "onComplete", "\n sdkstatus:" + arg0 + "\n result:" + arg1 );
    }
} );

useHeart： 在开始每一局（关）游戏之前，扣除体力的操作。

请求参数：

名称	说明
heart	消耗体力数量
返回参数：无

int heart;
MiCommplatform.getInstance().useHeart( GamActivity.this,heart,new MiResponseHandler()
{
    @Override
       protected void onError( int arg0, JSONObject arg1 )
    {
             alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
    }
       @Override
       protected void onComplete( int arg0, JSONObject arg1 )
    {
              alert( GamActivity.this, "onComplete", "\n sdkstatus:" + arg0 + "\n result:" + arg1 );
       }
} );

updateResult： 上传游戏成绩,此接口调用前需调用useHeart接口

请求参数：

名称	说明
score	每局游戏所得分数
leaderboardKey	某个积分榜的key,通过loadGameInfo接口获取
exp	每局游戏所得经验值
publicData	公开附加存储数据,可选参数最大值为1000byte
privateData	私有附加存储数据，可选参数最大值为2000byte

返回参数：无

String leaderboardKey;
int score;
int exp;
byte[] publicData;
byte[] preivateData;
MiCommplatform.getInstance().updateResult(GamActivity.this,leaderboardKey,score,  exp, publicData, privateData, new MiResponseHandler()
{
       @Override
       protected void onError( int arg0, JSONObject arg1 )
    {
             alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
    }
       @Override
       protected void onComplete( int arg0, JSONObject arg1 )
       {
             alert( GamActivity.this, "onComplete", arg1.toString() );
     }
} );

updateResults： 上传多个游戏成绩，此接口调用前需调用useHeart接口

请求参数：

名称	说明
scores	更新多个排行榜的成绩
exp	每局游戏所得经验值
publicData:	公开附加存储数据，可选参数最大值为1000byte
privateData:	私有附加存储数据，可选参数最大值为2000byte

返回参数：无

HashMap< String, Integer > scores;
int exp;
byte[] publicData;
byte[] privateData;
MiCommplatform.getInstance().updateResults(GamActivity.this,scores, exp,publicData, privateData, new MiResponseHandler()
{
      @Override
      protected void onError( int arg0, JSONObject arg1 )
    {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
      }
      @Override
      protected void onComplete( int arg0, JSONObject arg1 )
      {
            alert( GamActivity.this, "onComplete", arg1.toString() );
      }
} );

updateMe： 玩家购买或使用道具后，与服务器同步体力的变化信息。

请求参数：

名称	说明
heart	变化后的体力值
currentHeart	变化前的体力值
privateData	私有附加存储数据，可选参数最大值为2000byte
publicData	私有附加存储数据，可选参数最大值为2000byte

返回参数：无

int heart;
int currentHeart;
byte[] publicData;
byte[] privateData;
MiCommplatform.getInstance().updateMe(GamActivity.this,heart,currentHeart,publicData, privateData, new MiResponseHandler()
{
      @Override
      protected void onError( int arg0, JSONObject arg1 )
      {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
      }
      @Override
      protected void onComplete( int arg0, JSONObject arg1 )
    {
            alert( GamActivity.this, "onComplete", arg1.toString() );
      }
} );

sendGameMessage： 向某玩家赠送体力。

请求参数：

名称	说明
userId	接收者的游戏中心userId，通过loadGameFriends接口获得
message	传到聊天室的消息
gameMessage	游戏中收到的消息
data	用于发送更多的数据
返回参数：无

String userId;
String message;
String gameMsg;
Byte[] data;
ArrayList< Map< String, String >> metaInfo = new ArrayList< Map< String, String >>();
Map< String, String > metaInfoAndroid = new HashMap< String, String >();
metaInfoAndroid.put( "os", "android" );
metaInfoAndroid.put( "executeurl", "" );
metaInfo.add( metaInfoAndroid );
Map< String, String > metaInfoIos = new HashMap< String, String >();
metaInfoIos.put( "os", "ios" );
metaInfoIos.put( "executeurl", "" );
metaInfo.add( metaInfoIos );
MiCommplatform.getInstance().sendGameMessage( activity, userId, false, message, gameMsg, 1, data, metaInfo, new MiResponseHandler()
{
        @Override
        protected void onError( int arg0, JSONObject arg1 )
        {
            MessageUtil.alert( activity, "onError", "\n sdkstatus:" + arg0 );
        }
        @Override
        protected void onComplete( int arg0, JSONObject arg1 )
        {
            MessageUtil.alert( activity, "onComplete", arg1.toString() );
        }
} );
]

loadGameMessage： 读取好友赠送的体力消息列表

请求参数：无

返回参数：

名称	说明
messages	消息列表
消息列表参数
message_id	消息ID
sender_id	发送者的UID
sender_nickname	发送者昵称
sender_profile_image_url	发送者头像
heart	送了几点体力
message	消息内容（本期可以为空）
data	附加消息数据（本期可以为空）
sent_at	赠送体力的时间

MiCommplatform.getInstance().loadGameMessage(GameMessageActivity.this,new MiResponseHandler()
{
        @Override
        protected void onError( int miStatus, JSONObject result )
        {
                MessageUtil.alert( GameMessageActivity.this, "onError", "sdkStatus: " + miStatus + ", result: " + result );
        }
        @Override
        protected void onComplete( int miStatus, JSONObject result )
        {
              if ( !result.has( "messages" ) )
             {
                     Log.e( TAG, "message is null." );
                     return;
              }
              JSONArray messageArray = result.optJSONArray( "messages" );
              if ( messageArray.length() == 0 )
                    MessageUtil.alert( GameMessageActivity.this, "no message" );
              messages.clear();
              Log.i( TAG, "-------- messages" );
              for ( int i = 0, n = messageArray.length(); i < n; i++ )
              {
                 JSONObject message = messageArray.optJSONObject( i );
                    if ( message != null )
                    {
                             messages.add( message );
                 }
                    Log.i( TAG, "-------- messages[" + i + "]" );
                    Log.i( TAG, "message_id" + message.optString( "message_id" ) );
                    Log.i( TAG, "sender_id" + message.optString( "sender_id" ) );
                   Log.i(TAG,"sender_nickname" + message.optString( "sender_nickname" ) );
                    Log.i(TAG,"sender_profile_image_url" + message.optString( "sender_profile_image_url" ) );
                 Log.i( TAG, "heart" + message.optString( "heart" ) );
                    Log.i( TAG, "message" + message.optString("message" ) );
                    Log.i( TAG, "sent_at" + message.optString( "sent_at" ) );
                    String data = message.optString( "data" );
                    if ( data != null )
                    {
                           Log.i( TAG, "data : after- " + data );
                        byte[] decoded = Base64.decode( data, 0 );
                           data = new String( decoded );
                        Log.i( TAG, "data: before-" + data );
                    }
            }
            messageAdapeter.notifyDataSetChanged();
    }
    } );

acceptMessage： 接收体力。

请求参数

名称	说明
messageId	要接收消息的ID，通过loadGameMessage接口获得

返回参数：无

String messageId;
MiCommplatform.getInstance().acceptMessage(GameMessageActivity.this,messageId,new MiResponseHandler()
{
        @Override
        protected void onError( int miStatus, JSONObject result )
        {
            MessageUtil.alert( GameMessageActivity.this, result.toString() );
        }
        @Override
        protected void onComplete( int miStatus, JSONObject result )
        {
        }
} );

acceptAllMessage： 接收全部体力。

请求参数：无

返回参数：无

MiCommplatform.getInstance().acceptAllMessage(GameMessageActivity.this,
          new MiResponseHandler()
{
       @Override
       protected void onError( int miStatus, JSONObject result )
       {
         MessageUtil.alert( GameMessageActivity.this, result.toString());
       }
       @Override
       protected void onComplete( int miStatus, JSONObject result )
       {
       }
} );

messageBlock： 是否允许其他好友向自己赠送体力。

请求参数：

名称	说明
isMessageBlocked	是否允许好友赠送体力

返回参数：无

boolean  isMessageBlocked;
MiCommplatform.getInstance().messageBlock(GamActivity.this,isMessageBlocked,
       new MiResponseHandler()
{
     @Override
       protected void onError( int arg0, JSONObject arg1 )
       {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
       }
       @Override
       protected void onComplete( int arg0, JSONObject arg1 )
       {
            alert( GamActivity.this, "onComplete", arg1.toString() );
       }
} );

sendInviteMessage： 发送邀请好友消息（不建议使用）。

邀请米聊好友玩游戏流程： enter image description here 请求参数：

名称	说明
userId	接收者的游戏中心userId，通过loadGameFriends接口获得（兼容性参数传0即可）
message	消息内容（兼容性参数，消息内容由运营配置）

返回参数：无·

String userId;
String message;
ArrayList< Map< String, String >> metaInfo = new ArrayList< Map< String, String >>();
Map< String, String > metaInfoAndroid = new HashMap< String, String >();
metaInfoAndroid.put( "os", "android" );
metaInfoAndroid.put( "executeurl", "" );
metaInfo.add( metaInfoAndroid );
Map< String, String > metaInfoIos = new HashMap< String, String >();
metaInfoIos.put( "os", "ios" );
metaInfoIos.put( "executeurl", "" );
metaInfo.add( metaInfoIos );
MiCommplatform.getInstance().sendInviteMessage( activity, userId, false, message, metaInfo, new MiResponseHandler()
{
    @Override
       protected void onError( int arg0, JSONObject arg1 )
    {
      if(arg0 == 5200)
      {
       //取消邀请
      }
      else if(arg0 == -107)
      {
       //邀请失败
      }
    }
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {
     //邀请成功
    }
} );

sendInviteMessage 发送邀请好友消息邀请米聊好友玩游戏流程 enter image description here 请求参数：

名称	说明
title	标题
message	消息内容
imagePath	图片路径
返回参数：无

final String title = "一起来玩游戏吧";
final String message = "亲，赶紧来游戏让我抱抱大腿吧";
final String imagePath = "http://lxcdn.dl.files.xiaomi.net/mfsv2/avatar/s008/p01CveXl9AOC/Qg1BlgmzRbie7P_150.jpg";
MiCommplatform.getInstance().sendInviteMessage( GamActivity.this, title, message, imagePath, new MiResponseHandler()
{
    @Override
    protected void onError( int arg0, JSONObject arg1 )
    {
        MessageUtil.alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
        if ( arg0 == 5200 )
        {
            // 取消邀请
        }
        else if ( arg0 == -107 )
        {
            // 邀请失败
        }
    }
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {
        MessageUtil.alert( GamActivity.this, "onComplete", arg1.toString() );
        if ( arg0 == 0 )
        {
            // 邀请成功
        }
    }
} );

deleteMe： 删除分数（兼容性接口，不建议使用）。

请求参数：无

返回参数：无

MiCommplatform.getInstance().deleteMe(GameMessageActivity.this, new MiResponseHandler()
{
        @Override
     protected void onError( int miStatus, JSONObject result )
        {
            MessageUtil.alert( GameMessageActivity.this, result.toString() );
        }
        @Override
        protected void onComplete( int miStatus, JSONObject result )
        {
        }
} );

shareToMiTalk： 分享消息到米聊广播。

请求参数：

名称	说明
imagePath	图片路径
title	消息标题
message	分享默认文字
返回参数：无·

final String imagePath = Environment.getExternalStorageDirectory() + "/misdktest/testImg.png";
final String title = "大家一起来玩";
final String message = "测试";
MiCommplatform.getInstance().shareToMiTalk( GamActivity.this, imagePath, title, message, new MiResponseHandler()
    {
        @Override
        protected void onError( int arg0, JSONObject arg1 )
        {
            alert( GamActivity.this, "onError", "sdkstatus:" + arg0 );
            if ( arg0 == 5200 )
            {
                // 取消分享
            }
            else if ( arg0 == -107 )
            {
                // 分享失败
            }
        }
        @Override
        protected void onComplete( int arg0, JSONObject arg1 )
        {
            if ( arg0 == 0 )
            {
                // 分享成功
            }
        }
    } );

shareToMiTalkForLargeImg： 分享大图到圈子

请求参数：

名称	说明
imagePath	图片路径
message	分享默认文字
返回参数：无

final String imagePath = Environment.getExternalStorageDirectory() + "/misdktest/testImg.png";
final String message = "测试";
MiCommplatform.getInstance().shareToMiTalkForLargeImg( GamActivity.this, message, imagePath, new MiResponseHandler()
{
    @Override
    protected void onError( int arg0, JSONObject arg1 )
    {
        alert( GamActivity.this, "onError", "sdkstatus:" + arg0 );
        if ( arg0 == 5200 )
        {
            // 取消分享
        }
        else if ( arg0 == -107 )
        {
            // 分享失败
        }
    }
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {
        if ( arg0 == 0 )
        {
            // 分享成功
        }
    }
} );

syncResult： 上传游戏成绩,此接口调用前不需要调用useHeart接口，适合不适用米聊管理体力的游戏上传成绩。

请求参数：

名称	说明
score	分数
leaderboardKey	某个积分榜的key,通过loadGameInfo接口获取
exp	每局游戏所得经验值
publicData	公开附加存储数据,可选参数最大值为1000byte
privateData	私有附加存储数据,可选参数最大值为2000byte

返回参数：无

String leaderboardKey;
int score;
int exp;
byte[] publicData;
byte[] preivateData;
MiCommplatform.getInstance().syncResult(GamActivity.this,leaderboardKey,score,
    exp, publicData, privateData, new MiResponseHandler()
{
      @Override
      protected void onError( int arg0, JSONObject arg1 )
    {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
    }
      @Override
      protected void onComplete( int arg0, JSONObject arg1 )
    {
            alert( GamActivity.this, "onComplete", arg1.toString() );
    }
} );

syncResults： 上传多个游戏成绩，此接口调用前不需要调用useHeart接口，适合不需要米聊管理体力的游戏提交成绩。

请求参数：

名称	说明
scores	更新排行榜的成绩
exp	每局游戏所得经验值
public_data:	公开附加存储数据
private_data:	私有附加存储数据
返回参数：无

HashMap< String, Integer > scores;
int exp;
byte[] publicData;
byte[] privateData;
MiCommplatform.getInstance().syncResults(GamActivity.this,scores, exp,publicData, privateData, new MiResponseHandler()
{
       @Override
    protected void onError( int arg0, JSONObject arg1 )
     {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
    }
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {
            alert( GamActivity.this, "onComplete", arg1.toString() );
    }
} );

checkMiTalkStatus 检查米聊是否安装且登陆了

请求参数：无

返回参数：

名称	说明
code	0：安装并登陆 -1, 米聊有更新，-10001：没有安装-10002：米聊版本过低
message	错误信息

MiCommplatform.getInstance().checkMiTalkStatus( new MiResponseListener()
{
    @Override
    protected void onResponseStatus( int code, String message )
    {
        if ( code == 0 )
            alert( GamActivity.this, "Tip", "米聊已登录" );
        else
            alert( GamActivity.this, "Tip", "米聊不可用" );
    }
} );

joinUnion 申请加入公会

请求参数：

名称	说明
unionId	工会id
reason	加入理由

返回参数：

名称	说明
code	0：申请加入工会成功 -1：申请加入工会失败（重复加入时目前也返回-1）
messgae	错误信息

MiCommplatform.getInstance().joinUnion( unionId, new MiResponseListener()
{
    @Override
    protected void onResponseStatus( int code，String message )
    {
        alert( GamActivity.this, "Tip", "Code:" + code );
    }
} );

checkUnionStatus 查询是否已经在公会中

请求参数：

名称	说明
unionId	工会id

返回参数：

名称	说明
code	0：已加入工会 -1：未加入工会
message	错误信息

MiCommplatform.getInstance().checkJoinedUnion( unionId, new MiResponseListener()
{
    @Override
    protected void onResponseStatus( int code，String message )
    {
        alert( GamActivity.this, "Tip", "Code:" + code );
    }
} );

subscribeVip 关注某个服务号

请求参数

名称	说明
id	服务号id

返回参数：

名称	说明
code	0：关注成功 -1：关注失败
message	错误信息

MiCommplatform.getInstance().subscribeVip( vipId, new MiResponseListener()
{
    @Override
    protected void onResponseStatus( int code， String message )
    {
        alert( GamActivity.this, "Tip", "Code:" + code );
    }
} );

checkVipIsScubscribed 是否关注了某个服务号

请求参数：

名称	说明
id	服务号id

返回参数：

名称	说明
code	0：已关注 -1：未关注
message	错误信息

MiCommplatform.getInstance().checkVipIsScubscribed( vipId, new MiResponseListener()
{
    @Override
    protected void onResponseStatus( int code，String message )
    {
        alert( GamActivity.this, "Tip", "Code:" + code );
    }
} );

getUnionList 获取工会列表

请求参数：无

返回参数：无

MiCommplatform.getInstance().getUnionList( GamActivity.this, new MiResponseHandler()
{
    @Override
    protected void onError( int arg0, JSONObject arg1 )
    {
         alert( GamActivity.this, "", message );
    }
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {
         closeProgerssDialog();
         alert( GamActivity.this, "Tip", arg1.toString() );
    }
} );

getVipList 获取已关注列表

请求参数：无

返回参数：无

MiCommplatform.getInstance().getVipList( GamActivity.this, new MiResponseHandler()
{
    @Override
    protected void onError( int arg0, JSONObject arg1 )
    {
        alert( GamActivity.this, "Tip", "error" );
    }   
    @Override
    protected void onComplete( int arg0, JSONObject arg1 )
    {       
        alert( GamActivity.this, "Tip", arg1.toString() );
    }
} );

openMiTalkUpdateSite 打开米聊下载页面

请求参数：无

返回参数：无

MiCommplatform.getInstance().openMiTalkUpdateSite();

shareToMiTalkForImgAndUrl 图文分享

请求参数：

参数	类型	描述
defulText	String	分享时默认文本
title	String	标题
imagePath	String	小图路径
extraLargeImgPath	String	大图路径

返回参数：无

final String defulText = "测试";
final String title = "大家一起来玩";
final String imagePath = "http://lxcdn.dl.files.xiaomi.net/mfsv2/avatar/s008/p01CveXl9AOC/Qg1BlgmzRbie7P_150.jpg";
final String extraLargeImgPath = "http://lxcdn.dl.files.xiaomi.net/mfsv2/avatar/s008/p01CveXl9AOC/Qg1BlgmzRbie7P_150.jpg";
        /*Environment.getExternalStorageDirectory() + "/misdktest/testImg.png"*/;

MiCommplatform.getInstance().shareToMiTalkForImgAndUrl( GamActivity.this, defulText, title, imagePath, extraLargeImgPath, new MiResponseHandler()
    {

        @Override
        protected void onError( int arg0, JSONObject arg1 )
        {
            alert( GamActivity.this, "onError", "\n sdkstatus:" + arg0 );
        }

        @Override
        protected void onComplete( int arg0, JSONObject arg1 )
        {
            alert( GamActivity.this, "onComplete", arg1.toString() );
        }
    } );
}