Como posso gravar uma chamada conversa / telefone no iOS?

Question

É teoricamente possível gravar uma chamada no iPhone?

Eu estou aceitando respostas que:

• pode ou não pode exigir que o telefone seja jailbroken
• pode ou não passar diretrizes da Apple devido ao uso de API privada (Eu não me importo, não é para a App Store)
• pode ou não usar SDKs privadas

Eu não quero respostas apenas sem rodeios dizendo que "a Apple não permite isso." Eu sei que não haveria nenhuma maneira oficial de fazê-lo, e certamente não para um aplicativo da App Store, e eu sei que existem aplicativos de gravação de chamadas que colocam as chamadas efectuadas através dos seus próprios servidores.

Answer 1

Aqui está. exemplo de trabalho completo. Ajuste deve ser carregado em daemon mediaserverd. Ela irá gravar todas as chamadas de telefone em /var/mobile/Media/DCIM/result.m4a. arquivo de áudio tem dois canais. Esquerda é microfone, certo é alto-falante. Na chamada iPhone 4S é registrado somente quando o alto-falante está ligado. No iPhone 5, 5C e 5S chamada é gravada qualquer maneira. Pode haver pequenos soluços quando se muda de / para o alto-falante, mas a gravação continuará.

#import <AudioToolbox/AudioToolbox.h>
#import <libkern/OSAtomic.h>

//CoreTelephony.framework
extern "C" CFStringRef const kCTCallStatusChangeNotification;
extern "C" CFStringRef const kCTCallStatus;
extern "C" id CTTelephonyCenterGetDefault();
extern "C" void CTTelephonyCenterAddObserver(id ct, void* observer, CFNotificationCallback callBack, CFStringRef name, void *object, CFNotificationSuspensionBehavior sb);
extern "C" int CTGetCurrentCallCount();
enum
{
    kCTCallStatusActive = 1,
    kCTCallStatusHeld = 2,
    kCTCallStatusOutgoing = 3,
    kCTCallStatusIncoming = 4,
    kCTCallStatusHanged = 5
};

NSString* kMicFilePath = @"/var/mobile/Media/DCIM/mic.caf";
NSString* kSpeakerFilePath = @"/var/mobile/Media/DCIM/speaker.caf";
NSString* kResultFilePath = @"/var/mobile/Media/DCIM/result.m4a";

OSSpinLock phoneCallIsActiveLock = 0;
OSSpinLock speakerLock = 0;
OSSpinLock micLock = 0;

ExtAudioFileRef micFile = NULL;
ExtAudioFileRef speakerFile = NULL;

BOOL phoneCallIsActive = NO;

void Convert()
{
    //File URLs
    CFURLRef micUrl = CFURLCreateWithFileSystemPath(NULL, (CFStringRef)kMicFilePath, kCFURLPOSIXPathStyle, false);
    CFURLRef speakerUrl = CFURLCreateWithFileSystemPath(NULL, (CFStringRef)kSpeakerFilePath, kCFURLPOSIXPathStyle, false);
    CFURLRef mixUrl = CFURLCreateWithFileSystemPath(NULL, (CFStringRef)kResultFilePath, kCFURLPOSIXPathStyle, false);

    ExtAudioFileRef micFile = NULL;
    ExtAudioFileRef speakerFile = NULL;
    ExtAudioFileRef mixFile = NULL;

    //Opening input files (speaker and mic)
    ExtAudioFileOpenURL(micUrl, &micFile);
    ExtAudioFileOpenURL(speakerUrl, &speakerFile);

    //Reading input file audio format (mono LPCM)
    AudioStreamBasicDescription inputFormat, outputFormat;
    UInt32 descSize = sizeof(inputFormat);
    ExtAudioFileGetProperty(micFile, kExtAudioFileProperty_FileDataFormat, &descSize, &inputFormat);
    int sampleSize = inputFormat.mBytesPerFrame;

    //Filling input stream format for output file (stereo LPCM)
    FillOutASBDForLPCM(inputFormat, inputFormat.mSampleRate, 2, inputFormat.mBitsPerChannel, inputFormat.mBitsPerChannel, true, false, false);

    //Filling output file audio format (AAC)
    memset(&outputFormat, 0, sizeof(outputFormat));
    outputFormat.mFormatID = kAudioFormatMPEG4AAC;
    outputFormat.mSampleRate = 8000;
    outputFormat.mFormatFlags = kMPEG4Object_AAC_Main;
    outputFormat.mChannelsPerFrame = 2;

    //Opening output file
    ExtAudioFileCreateWithURL(mixUrl, kAudioFileM4AType, &outputFormat, NULL, kAudioFileFlags_EraseFile, &mixFile);
    ExtAudioFileSetProperty(mixFile, kExtAudioFileProperty_ClientDataFormat, sizeof(inputFormat), &inputFormat);

    //Freeing URLs
    CFRelease(micUrl);
    CFRelease(speakerUrl);
    CFRelease(mixUrl);

    //Setting up audio buffers
    int bufferSizeInSamples = 64 * 1024;

    AudioBufferList micBuffer;
    micBuffer.mNumberBuffers = 1;
    micBuffer.mBuffers[0].mNumberChannels = 1;
    micBuffer.mBuffers[0].mDataByteSize = sampleSize * bufferSizeInSamples;
    micBuffer.mBuffers[0].mData = malloc(micBuffer.mBuffers[0].mDataByteSize);

    AudioBufferList speakerBuffer;
    speakerBuffer.mNumberBuffers = 1;
    speakerBuffer.mBuffers[0].mNumberChannels = 1;
    speakerBuffer.mBuffers[0].mDataByteSize = sampleSize * bufferSizeInSamples;
    speakerBuffer.mBuffers[0].mData = malloc(speakerBuffer.mBuffers[0].mDataByteSize);

    AudioBufferList mixBuffer;
    mixBuffer.mNumberBuffers = 1;
    mixBuffer.mBuffers[0].mNumberChannels = 2;
    mixBuffer.mBuffers[0].mDataByteSize = sampleSize * bufferSizeInSamples * 2;
    mixBuffer.mBuffers[0].mData = malloc(mixBuffer.mBuffers[0].mDataByteSize);

    //Converting
    while (true)
    {
        //Reading data from input files
        UInt32 framesToRead = bufferSizeInSamples;
        ExtAudioFileRead(micFile, &framesToRead, &micBuffer);
        ExtAudioFileRead(speakerFile, &framesToRead, &speakerBuffer);
        if (framesToRead == 0)
        {
            break;
        }

        //Building interleaved stereo buffer - left channel is mic, right - speaker
        for (int i = 0; i < framesToRead; i++)
        {
            memcpy((char*)mixBuffer.mBuffers[0].mData + i * sampleSize * 2, (char*)micBuffer.mBuffers[0].mData + i * sampleSize, sampleSize);
            memcpy((char*)mixBuffer.mBuffers[0].mData + i * sampleSize * 2 + sampleSize, (char*)speakerBuffer.mBuffers[0].mData + i * sampleSize, sampleSize);
        }

        //Writing to output file - LPCM will be converted to AAC
        ExtAudioFileWrite(mixFile, framesToRead, &mixBuffer);
    }

    //Closing files
    ExtAudioFileDispose(micFile);
    ExtAudioFileDispose(speakerFile);
    ExtAudioFileDispose(mixFile);

    //Freeing audio buffers
    free(micBuffer.mBuffers[0].mData);
    free(speakerBuffer.mBuffers[0].mData);
    free(mixBuffer.mBuffers[0].mData);
}

void Cleanup()
{
    [[NSFileManager defaultManager] removeItemAtPath:kMicFilePath error:NULL];
    [[NSFileManager defaultManager] removeItemAtPath:kSpeakerFilePath error:NULL];
}

void CoreTelephonyNotificationCallback(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo)
{
    NSDictionary* data = (NSDictionary*)userInfo;

    if ([(NSString*)name isEqualToString:(NSString*)kCTCallStatusChangeNotification])
    {
        int currentCallStatus = [data[(NSString*)kCTCallStatus] integerValue];

        if (currentCallStatus == kCTCallStatusActive)
        {
            OSSpinLockLock(&phoneCallIsActiveLock);
            phoneCallIsActive = YES;
            OSSpinLockUnlock(&phoneCallIsActiveLock);
        }
        else if (currentCallStatus == kCTCallStatusHanged)
        {
            if (CTGetCurrentCallCount() > 0)
            {
                return;
            }

            OSSpinLockLock(&phoneCallIsActiveLock);
            phoneCallIsActive = NO;
            OSSpinLockUnlock(&phoneCallIsActiveLock);

            //Closing mic file
            OSSpinLockLock(&micLock);
            if (micFile != NULL)
            {
                ExtAudioFileDispose(micFile);
            }
            micFile = NULL;
            OSSpinLockUnlock(&micLock);

            //Closing speaker file
            OSSpinLockLock(&speakerLock);
            if (speakerFile != NULL)
            {
                ExtAudioFileDispose(speakerFile);
            }
            speakerFile = NULL;
            OSSpinLockUnlock(&speakerLock);

            Convert();
            Cleanup();
        }
    }
}

OSStatus(*AudioUnitProcess_orig)(AudioUnit unit, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inNumberFrames, AudioBufferList *ioData);
OSStatus AudioUnitProcess_hook(AudioUnit unit, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inNumberFrames, AudioBufferList *ioData)
{
    OSSpinLockLock(&phoneCallIsActiveLock);
    if (phoneCallIsActive == NO)
    {
        OSSpinLockUnlock(&phoneCallIsActiveLock);
        return AudioUnitProcess_orig(unit, ioActionFlags, inTimeStamp, inNumberFrames, ioData);
    }
    OSSpinLockUnlock(&phoneCallIsActiveLock);

    ExtAudioFileRef* currentFile = NULL;
    OSSpinLock* currentLock = NULL;

    AudioComponentDescription unitDescription = {0};
    AudioComponentGetDescription(AudioComponentInstanceGetComponent(unit), &unitDescription);
    //'agcc', 'mbdp' - iPhone 4S, iPhone 5
    //'agc2', 'vrq2' - iPhone 5C, iPhone 5S
    if (unitDescription.componentSubType == 'agcc' || unitDescription.componentSubType == 'agc2')
    {
        currentFile = &micFile;
        currentLock = &micLock;
    }
    else if (unitDescription.componentSubType == 'mbdp' || unitDescription.componentSubType == 'vrq2')
    {
        currentFile = &speakerFile;
        currentLock = &speakerLock;
    }

    if (currentFile != NULL)
    {
        OSSpinLockLock(currentLock);

        //Opening file
        if (*currentFile == NULL)
        {
            //Obtaining input audio format
            AudioStreamBasicDescription desc;
            UInt32 descSize = sizeof(desc);
            AudioUnitGetProperty(unit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &desc, &descSize);

            //Opening audio file
            CFURLRef url = CFURLCreateWithFileSystemPath(NULL, (CFStringRef)((currentFile == &micFile) ? kMicFilePath : kSpeakerFilePath), kCFURLPOSIXPathStyle, false);
            ExtAudioFileRef audioFile = NULL;
            OSStatus result = ExtAudioFileCreateWithURL(url, kAudioFileCAFType, &desc, NULL, kAudioFileFlags_EraseFile, &audioFile);
            if (result != 0)
            {
                *currentFile = NULL;
            }
            else
            {
                *currentFile = audioFile;

                //Writing audio format
                ExtAudioFileSetProperty(*currentFile, kExtAudioFileProperty_ClientDataFormat, sizeof(desc), &desc);
            }
            CFRelease(url);
        }
        else
        {
            //Writing audio buffer
            ExtAudioFileWrite(*currentFile, inNumberFrames, ioData);
        }

        OSSpinLockUnlock(currentLock);
    }

    return AudioUnitProcess_orig(unit, ioActionFlags, inTimeStamp, inNumberFrames, ioData);
}

__attribute__((constructor))
static void initialize()
{
    CTTelephonyCenterAddObserver(CTTelephonyCenterGetDefault(), NULL, CoreTelephonyNotificationCallback, NULL, NULL, CFNotificationSuspensionBehaviorHold);

    MSHookFunction(AudioUnitProcess, AudioUnitProcess_hook, &AudioUnitProcess_orig);
}

Algumas palavras sobre o que está acontecendo. função AudioUnitProcess é usado para o processamento de fluxos de áudio, a fim de aplicar alguns efeitos, misturar, converter etc. Estamos ligando AudioUnitProcess, a fim de fluxos de áudio acesso do telefonema. Enquanto telefonema é ativa esses fluxos estão sendo processados ??de várias maneiras.

Estamos ouvindo notificações CoreTelephony a fim de obter mudanças de status de chamadas de telefone. Quando recebemos amostras de áudio precisamos determinar de onde eles vêm - microfone ou alto-falante. Isso é feito usando campo componentSubType na estrutura AudioComponentDescription. Agora, você pode pensar, por que não vamos armazenar AudioUnit objetos de modo que nós não precisamos de verificar componentSubType cada vez. Eu fiz isso, mas ele vai quebrar tudo quando você alternar alto-falante on / off no iPhone 5 porque os objetos AudioUnit vai mudar, eles são recriados. Então, agora vamos abrir arquivos de áudio (um para microfone e um alto-falante para) e amostras de escrita neles, simples como isso. Quando telefonema termina vamos receber notificação CoreTelephony apropriado e feche os arquivos. Nós temos dois arquivos separados com áudio do microfone e alto-falante que precisamos mesclagem. Isto é o que void Convert() é para. É muito simples se você sabe o API. Eu não acho que eu preciso explicar isso, os comentários são suficientes.

Sobre bloqueios. Há muitos tópicos em mediaserverd. processamento de áudio e notificações CoreTelephony estão em segmentos diferentes por isso precisamos de alguns sincronização tipo. Eu escolhi bloqueios de rotação, porque eles são rápidos e porque a chance de contenção de bloqueio é pequeno em nosso caso. No iPhone 4S e até mesmo iPhone 5 todo o trabalho em AudioUnitProcess deve ser feito o mais rápido possível caso contrário você vai ouvir soluços de alto-falante dispositivo que, obviamente, não é bom.

Answer 2

Sim. Audio Recorder por um desenvolvedor chamado Limneos faz isso (e muito bem). Você pode encontrá-lo no Cydia. Pode gravar qualquer tipo de chamada no iPhone 5 e sem usar qualquer servidores etc'. A chamada será colocada sobre o dispositivo em um arquivo de áudio. Ele também suporta iPhone 4S, mas por alto-falante só.

Este mecanismo é conhecido por ser o primeiro ajuste já que conseguiu gravar ambos os fluxos de áudio sem utilizar qualquer severs 3rd party, VOIP ou algo similar.

O desenvolvedor colocado beeps do outro lado da chamada para alertar a pessoa que está a gravar mas aqueles foram removidos também por hackers através da rede. Para responder à sua pergunta, sim, é muito possível, e não apenas teoricamente.

Leitura

• https://stackoverflow.com/a/19413363/202451
• http://forums.macrumors.com/showthread.php?t=1566350
• https://github.com/nst/iOS-Runtime-Headers

Answer 3

A única solução que eu posso pensar é usar o Núcleo de telefonia quadro e, mais especificamente, a callEventHandler propriedade, para interceptar quando uma chamada está chegando, e, em seguida, usar um AVAudioRecorder para gravar a voz da pessoa com o telefone (e talvez um pouco da pessoa na voz da outra linha). Esta é, obviamente, não é perfeito, e só funcionaria se o aplicativo estiver em primeiro plano no momento da chamada, mas pode ser o melhor que você pode obter. Veja mais sobre descobrir se existe uma chamada telefônica aqui: podemos acionar um evento quando sempre há Incoming e chamada de saída no iphone? .

EDIT:

.h:

#import <AVFoundation/AVFoundation.h>
#import<CoreTelephony/CTCallCenter.h>
#import<CoreTelephony/CTCall.h>
@property (strong, nonatomic) AVAudioRecorder *audioRecorder;

ViewDidLoad:

NSArray *dirPaths;
NSString *docsDir;

dirPaths = NSSearchPathForDirectoriesInDomains(
    NSDocumentDirectory, NSUserDomainMask, YES);
docsDir = dirPaths[0];

NSString *soundFilePath = [docsDir
   stringByAppendingPathComponent:@"sound.caf"];

NSURL *soundFileURL = [NSURL fileURLWithPath:soundFilePath];

NSDictionary *recordSettings = [NSDictionary
        dictionaryWithObjectsAndKeys:
        [NSNumber numberWithInt:AVAudioQualityMin],
        AVEncoderAudioQualityKey,
        [NSNumber numberWithInt:16],
        AVEncoderBitRateKey,
        [NSNumber numberWithInt: 2],
        AVNumberOfChannelsKey,
        [NSNumber numberWithFloat:44100.0],
        AVSampleRateKey,
        nil];

NSError *error = nil;

_audioRecorder = [[AVAudioRecorder alloc]
              initWithURL:soundFileURL
              settings:recordSettings
              error:&error];

 if (error)
 {
       NSLog(@"error: %@", [error localizedDescription]);
 } else {
       [_audioRecorder prepareToRecord];
 }

CTCallCenter *callCenter = [[CTCallCenter alloc] init];

[callCenter setCallEventHandler:^(CTCall *call) {
  if ([[call callState] isEqual:CTCallStateConnected]) {
    [_audioRecorder record];
  } else if ([[call callState] isEqual:CTCallStateDisconnected]) {
    [_audioRecorder stop];
  }
}];

AppDelegate.m:

- (void)applicationDidEnterBackground:(UIApplication *)application//Makes sure that the recording keeps happening even when app is in the background, though only can go for 10 minutes.
{
    __block UIBackgroundTaskIdentifier task = 0;
    task=[application beginBackgroundTaskWithExpirationHandler:^{
    NSLog(@"Expiration handler called %f",[application backgroundTimeRemaining]);
    [application endBackgroundTask:task];
    task=UIBackgroundTaskInvalid;
}];

Esta é a primeira vez que utiliza muitos desses recursos, por isso não tenho certeza se este é exatamente certo, mas acho que você começa a idéia. Testado, como eu não tem acesso às ferramentas certas no momento. Compilado usando essas fontes:

• gravação de voz no fundo usando AVAudioRecorder

• http: // prassan-warrior.blogspot.com/2012/11/recording-audio-on-iphone-with.html

• podemos acionar um evento quando sempre há Incoming e chamada de saída no iphone?

Answer 4

Apple não permite isso e não fornece nenhuma API para ele.

No entanto, em um dispositivo jailbroken eu tenho certeza que é possível. Por uma questão de fato, eu acho que já está feito. Eu lembro de ter visto um aplicativo quando o meu telefone foi jailbroken que mudou a sua voz e gravou a chamada - Eu lembro que era uma empresa americana que oferece apenas nos estados. Infelizmente eu não me lembro o nome ...

Answer 5

Eu acho que algum hardware poderia resolver isso. Ligado ao Minijack-porta; Tendo auriculares e um microfone que passa através de um pequeno gravador. Este gravador pode ser muito simples. Embora não em conversa o gravador poderia alimentar o telefone com os dados de / a gravação (através da tomada-cabo). E com um botão de arranque simples (como os controles Volum sobre os fones de ouvido) poderia ser suficiente para cronometrar a gravação.

Algumas configurações

• http: // www .danmccomb.com / posts / 483 / how-to-record-iphone conversas usando-zoom-H4n /
• http://forums.macrumors.com/showthread.php?t=346430