Iphone 使用蓝牙在其他设备上播放歌曲

我的应用程序中有此歌曲播放列表。我想使用蓝牙在另一台设备（iphone）上播放此播放列表中的歌曲

这就是我这么做的原因

#import "BrowseStationsViewController.h"

@interface BrowseStationsViewController (){
GKSession *gkSession;
}

@end

@implementation BrowseStationsViewController

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
 self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
if (self) {
    // Custom initialization
}
return self;
 }

#pragma mark - 
  - (void)viewDidLoad
{
   [super viewDidLoad];
// Do any additional setup after loading the view

   [self setupSession];

NSNotificationCenter *defaultCenter = [NSNotificationCenter defaultCenter];

// Register for notifications when the application leaves the background state
// on its way to becoming the active application.
[defaultCenter addObserver:self
                  selector:@selector(setupSession)
                      name:UIApplicationWillEnterForegroundNotification
                    object:nil];

// Register for notifications when when the application enters the background.
[defaultCenter addObserver:self
                  selector:@selector(teardownSession)
                      name:UIApplicationDidEnterBackgroundNotification
                    object:nil];


       }

- (void)didReceiveMemoryWarning
 {
 [super didReceiveMemoryWarning];
// Dispose of any resources that can be recreated.
   }



     #pragma mark - GKSession setup and teardown

  - (void)setupSession
 {
gkSession = [[GKSession alloc] initWithSessionID:nil displayName:nil sessionMode:GKSessionModePeer];
gkSession.delegate = self;
gkSession.disconnectTimeout = kDisconnectTimeout;
gkSession.available = YES;

self.title = [NSString stringWithFormat:@"GKSession: %@", gkSession.displayName];
   }

 - (void)teardownSession
 {
[gkSession disconnectFromAllPeers];
gkSession.available = NO;
gkSession.delegate = nil;
 }


 #pragma mark - GKSessionDelegate protocol conformance

 - (void)session:(GKSession *)session peer:(NSString *)peerID didChangeState:     (GKPeerConnectionState)state
{
switch (state)
{
    case GKPeerStateAvailable:
    {
        NSLog(@"didChangeState: peer %@ available", [session displayNameForPeer:peerID]);

        [NSThread sleepForTimeInterval:kSleepTimeInterval];

        [session connectToPeer:peerID withTimeout:kConnectionTimeout];
        break;
    }

    case GKPeerStateUnavailable:
    {
        NSLog(@"didChangeState: peer %@ unavailable", [session displayNameForPeer:peerID]);
        break;
    }

    case GKPeerStateConnected:
    {
        NSLog(@"didChangeState: peer %@ connected", [session displayNameForPeer:peerID]);
        break;
    }

    case GKPeerStateDisconnected:
    {
        NSLog(@"didChangeState: peer %@ disconnected", [session displayNameForPeer:peerID]);
        break;
    }

    case GKPeerStateConnecting:
    {
        NSLog(@"didChangeState: peer %@ connecting", [session displayNameForPeer:peerID]);
        break;
    }
}

[self.tableView reloadData];
     }


- (void)session:(GKSession *)session didReceiveConnectionRequestFromPeer:(NSString  *)peerID
   {
NSLog(@"didReceiveConnectionRequestFromPeer: %@", [session displayNameForPeer:peerID]);

[session acceptConnectionFromPeer:peerID error:nil];

[self.tableView reloadData];
   }

    - (void)session:(GKSession *)session connectionWithPeerFailed:(NSString *)peerID withError:(NSError *)error
  {
NSLog(@"connectionWithPeerFailed: peer: %@, error: %@", [session displayNameForPeer:peerID], error);

[self.tableView reloadData];
    }

 - (void)session:(GKSession *)session didFailWithError:(NSError *)error
  {
NSLog(@"didFailWithError: error: %@", error);

[session disconnectFromAllPeers];

[self.tableView reloadData];
    }

 #pragma mark - UITableViewDataSource protocol conformance

 - (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
  {
// We have 5 sections in our grouped table view,
// one for each GKPeerConnectionState
return 3;
   }

   - (NSInteger)tableView:(UITableView *)table numberOfRowsInSection:(NSInteger)section
  {
NSInteger rows;

NSInteger peerConnectionState = section;

switch (peerConnectionState)
{
    case GKPeerStateAvailable:
    {
        NSArray *availablePeers = [gkSession peersWithConnectionState:GKPeerStateAvailable];
        rows = availablePeers.count;
        break;
    }

    case GKPeerStateConnected:
    {
        NSArray *connectedPeers = [gkSession peersWithConnectionState:GKPeerStateConnected];
        rows = connectedPeers.count;
        break;
    }

    case GKPeerStateUnavailable:
    {
        NSArray *unavailablePeers = [gkSession peersWithConnectionState:GKPeerStateUnavailable];
        rows = unavailablePeers.count;
        break;
    }
}

// Always show at least 1 row for each GKPeerConnectionState.
if (rows < 1)
{
    rows = 1;
}

return rows;
}

- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section
{
NSString *headerTitle = nil;

NSInteger peerConnectionState = section;

switch (peerConnectionState)
{
    case GKPeerStateAvailable:
    {
        headerTitle = @"Available Peers";
        break;
    }


    case GKPeerStateConnected:
    {
        headerTitle = @"Connected Peers";
        break;
    }


    case GKPeerStateUnavailable:
    {
        headerTitle = @"Unavailable Peers";
        break;
    }
}

return headerTitle;
 }

 - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
NSString * cellId = @"Cell";
UITableViewCell * cell = [tableView dequeueReusableCellWithIdentifier:cellId];
if(!cell){
    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:cellId];
}


NSInteger peerConnectionState = indexPath.section;

NSArray *peers = nil;

switch (peerConnectionState)
{
    case GKPeerStateAvailable:
    {
        peers = [gkSession peersWithConnectionState:GKPeerStateAvailable];
        break;
    }

    case GKPeerStateConnected:
    {
        peers = [gkSession peersWithConnectionState:GKPeerStateConnected];
        break;
    }


    case GKPeerStateUnavailable:
    {
        peers = [gkSession peersWithConnectionState:GKPeerStateUnavailable];
        break;
    }
}

NSInteger peerIndex = indexPath.row;

if ((peers.count > 0) && (peerIndex < peers.count))
{
    NSString *peerID = [peers objectAtIndex:peerIndex];

    if (peerID)
    {
        cell.textLabel.text = [gkSession displayNameForPeer:peerID];
    }
}

return cell;
 }

  @end

#导入“BrowseStationViewController.h”
@接口BrowseStationViewController（）{
GK会议*GK会议；
}
@结束
@实现BrowseStationViewController
-（id）initWithNibName:（NSString*）nibNameOrNil bundle:（NSBundle*）nibBundleOrNil
{
self=[super initWithNibName:nibNameOrNil bundle:nibBundleOrNil]；
如果（自我）{
//自定义初始化
}
回归自我；
}
#布拉格标记-
-（无效）viewDidLoad
{
[超级视图下载]；
//加载视图后执行任何其他设置
[自我设置会话]；
NSNotificationCenter*defaultCenter=[NSNotificationCenter defaultCenter]；
//当应用程序离开后台状态时注册通知
//正在成为活跃的应用程序。
[defaultCenter addObserver:self
选择器：@选择器（设置会话）
名称：UIApplicationWillEnterForegroundNotification
对象：无]；
//当应用程序进入后台时注册通知。
[defaultCenter addObserver:self
选择器：@selector（拆卸会话）
名称：UIApplicationIdentinterBackgroundNotification
对象：无]；
}
-（无效）未收到记忆警告
{
[超级记忆警告]；
//处置所有可以重新创建的资源。
}
#pragma标记-GK会话设置和拆卸
-（作废）会议
{
gkSession=[[gkSession alloc]initWithSessionID:nil displayName:nil sessionMode:GKSessionModePeer]；
gkSession.delegate=self；
gkSession.disconnectTimeout=kDisconnectTimeout；
gkSession.available=是；
self.title=[NSString stringWithFormat:@“GKSession:%@”，GKSession.displayName]；
}
-（无效）拆卸会话
{
[gk会话断开与所有对等方的连接]；
gkSession.available=否；
gkSession.delegate=nil；
}
#pragma-mark-gksessionelegate协议一致性
-（void）session:（GKSession*）session peer:（NSString*）peerID didChangeState:（GKPeerConnectionState）状态
{
开关（状态）
{
案例GKpeerStates可用：
{
NSLog（@“didChangeState:peer%@available”，[sessiondisplaynameforpeer:peerID]）；
[NSThread sleepForTimeInterval:kSleepTimeInterval]；
[session connectToPeer:peerID with Timeout:kConnectionTimeout]；
打破
}
案例GKpeerStates不可用：
{
NSLog（@“didChangeState:peer%@不可用”，[sessiondisplaynameforpeer:peerID]）；
打破
}
案例GKpeerStateTonnected：
{
NSLog（@“didChangeState:peer%@connected”，[sessiondisplaynameforpeer:peerID]）；
打破
}
案例GKpeerStates断开：
{
NSLog（@“didChangeState:peer%@已断开连接”，[session displayNameForPeer:peerID]）；
打破
}
案例GKpeerstate连接：
{
NSLog（@“didChangeState:peer%@connecting”，[sessiondisplaynameforpeer:peerID]）；
打破
}
}
[self.tableView重载数据]；
}
-（void）session:（GKSession*）session didReceiveConnectionRequestFromPeer:（NSString*）peerID
{
NSLog（@“didReceiveConnectionRequestFromPeer:%@，[session displayNameForPeer:peerID]）；
[session acceptConnectionFromPeer:peerID错误：nil]；
[self.tableView重载数据]；
}
-（void）session:（GKSession*）session connectionWithPeerFailed:（NSString*）peerID withError:（NSError*）错误
{
NSLog（@“connectionWithPeerFailed:peer:%@，错误：%@，[session displayNameForPeer:peerID]，错误）；
[self.tableView重载数据]；
}
-（void）会话：（GKSession*）会话失败错误：（NSError*）错误
{
NSLog（@“错误：错误：%@”，错误）；
[会话断开与所有对等方的连接]；
[self.tableView重载数据]；
}
#pragma标记-UITableViewDataSource协议一致性
-（NSInteger）表格视图中的节数：（UITableView*）表格视图
{
//在分组表视图中有5个部分，
//每个GKPeerConnectionState一个
返回3；
}
-（NSInteger）表格视图：（UITableView*）表格行数节：（NSInteger）节
{
NSInteger行；
NSInteger peerConnectionState=截面；
开关（对等连接状态）
{
案例GKpeerStates可用：
{
NSArray*availablePeers=[gkSession peersWithConnectionState:GKPeerStateAvailable]；
行=availablePeers.count；
打破
}
案例GKpeerStateTonnected：
{
NSArray*connectedPeers=[gkSession peersWithConnectionState:GKPeerStateConnected]；
行=connectedPeers.count；
打破
}
案例GKpeerStates不可用：
{
NSArray*不可用对等点=[gkSession peersWithConnectionState:GKPeerStateUnavailable]；
行=不可用的对等点。计数；
打破
}
}
//始终为每个GKPeerConnectionState至少显示一行。
如果（行数<1）
{
行=1；
}
返回行；
}
-（NSString*）表格视图：（UITableView*）表格视图标题标题标题部分：（NSInteger）部分
{
NSString*headerTitle=nil；
NSInteger peerConnectionState=截面；
开关（对等连接状态）
{
案例GKpeerStates可用：
{
headerTitle=@“可用的对等方”；
打破
}
案例GKpeerStateTonnected：
{
headerTitle=@“连接的对等方”；
打破
}
案例GKpeerStates不可用：
{
headerTitle=@“不可用的对等点”；
打破
}
}
回程航向；
}
-（UITableViewCell*）tableView:（UITableView*）tableView cellForRowAtIndexPath:（NSIndexPath*）indexPath
{
NSString*cellId=@“Cell”；
UITableViewCell*单元格=[tableView dequeueReusableCellWithIdentifier:cellId]；
如果（！单元格）{
cell=[[UITableViewCell alloc]initWithStyle:UITableViewCellStyleSubtitle重用标识符：cellId]；
}
NSInteger-peerConnectionState=indexPath.section；
NSArray*对等方=零；
开关（对等连接状态）
{
案例GKpeerStates可用：
{
peers=[gkSession PeerWith ConnectionState:GKPeerStateAvail